自学java基础笔记

java基础教程
基础字符
public  公共的
class 类
static 静态的
void 无返回类型
main 主要的
String 字符串
args 参数
System 系统的
out 输出设备
print 打印
println  打印并换行
\t 输出八个空格 相当于制表位
\n 换行
//注释符  后面跟注释 计算机不执行
/*
多行注释   中间跟注释  不执行
*/ 


数据类型说明
char（字符型） 用于存储单个字符 用单引号
int（整型） 用于存储整数 用等号
double（双精度） 用于存储小数 用等号
String（字符串） 用于存数一串字符 用双引号
步骤
1.数据类型
语法：数据类型 变量名
int house;
String name;
double li;
2.给变量赋值
语法：变量名=值
house=3;
name="张三";


java里的关键字不能作为变量名


变量命名规则
变量名=1.字母 1.数字
2.下划线'_' +   2.字母
3.$符号 3.下划线
4.$符号
变量命名规范
简短且能清楚地表明变量的作用，通常第一个单词的首字母小写其后单词的首字母大写 如：myScore
Java区分大小写
bScore=aScore;//将右边的值给左边的变量


加号可以是算数运算符，也可以是一个连接符
1.当两个都是非数值类型时，如果他们相加就会被看做一个连接符
2.当一个是非数值类型，另一个是数值类型时他们会被看做一个连接符
3.当两个都是数值类型时他们会被看做一个算数运算符


认识%号  （取模也可以称它为取余）
int days=46;
double wek=days/7;
System.out.println("有"+wek+"周");
int days1=days%7;//days代表的数值除于7所余的数
System.out.println("剩"+days1+"天");


数据类型的自动转换
double大于int   a+b=double double不能转换为int
String大于char  a+b=String String不能转换为char


数据类型的强制转换
（1）int year=20;
double f=9.8;
int newYear=year+(int)9.8;//小括号里写类型名,转换的是括号后的数字
System.out.println(newYear);
（2）int radius=10;
double high=1.9;
int value=(int)(3.14*radius*radius*high);//加括号表示强制转换括号里所得的数值
(类型名)表达式
char类型不能转换为String类型


数据的输入
Scanner 扫描仪
import 导入
in 输入设备
1.引入扫描仪,在首层输入import java.util.Scanner//导入java.util里的扫描仪
2.声明一个扫描仪
Scanner in;//in是Scanner的名字
3.赋值
in=new Scanner(System.in);
4.使用扫描仪
整数数据输入:in.nextInt()来接收
双精度小数输入:in.nextDouble()来接收
字符串输入:in.next()来接收


没有in.nextChar()这个方法来接收单个字符的输入
import java.util.Scanner;
public class Test1{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入你的姓名:");
String name=in.next()
System.out.println("请输入你的年龄");
int age=in.nextInt();
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
}
}


运算符和条件结构
数据交换
public class E{
public static void main(String[] args){
int A=45;
int B=78;
int t=A;
A=B;
B=t;
System.out.println("A的值为"+A);
System.out.print("B的值为"+B);
}
}
boolean(布尔)类型  值:
真:true
假:false
> 大于
>=大于等于
< 小于
<=小于等于
!=不等于
==恒等于
public class F{
public static void main(String[] args){
int A=2;
int B=2;
boolean flag;
flag=A!=B;
System.out.println(flag);
}
}


*号可以声明Scanner
*号表示导入java.util的所有的东西
import java.util.*;
public class G{
public static void main(String[] args){


}
}
if语句
import java.util.*;
public class G{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入你的成绩:");
int score=in.nextInt();
if(score>90==false){//score大于90等于假的就是小于等于90
System.out.println("奖励你一根棒棒糖");
}
}
}
思考题：
实现一个计算机，如果输入的数为1就把两个变量进行相加随后输出和，如果输入的数为2就对两个变量进行相减随后输出它们的差。
代码：
import java.util.Scanner;
public class I{
public static void main(String[] args){
int C=5;
int D=15;
int E=0;//给E赋值，不赋值不能执行。赋值0是规范。
Scanner A=new Scanner(System.in);
System.out.println("请输入1或2:");
int B=A.nextInt();
if(B==1){
E=C+D;
}
if(B==2){
E=C-D;
}
System.out.println("值为:"+E);
}
}


逻辑运算符
&&  条件1&&条件2 仅仅两个条件同时为真，结果为真。有一个为假，就为假。
||  条件1||条件2 只要两个条件有一个为真，结果为真。两个都为假，就为假。
!   !条件 条件为真时，结果为假.条件为假时，结果为真。


代码
import java.util.Scanner;
public class Test0{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入你的java成绩:");
int java=in.nextInt();
System.out.println("请输入SQL成绩");
int sql=in.nextInt();
if(java>90&&sql>90){/*
可换为 java>90||sql>90。或if(!(java>90&&sql>90))则否定括号里的
*/
System.out.println("给你一本独孤九剑");
}
System.out.println("测试");
}
}
作业:年龄小于25月薪大于10000输出"哇,你是高富帅啊?"
年龄大于25月薪小于10000输出"死穷逼!"，
否则则输出"呵呵!"
import java.util.*;
public class ceshi{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入你的年龄");
int A=in.nextInt();
System.out.println("请输入你的月薪");
int B=in.nextInt();
if(A<25&&B>10000){
System.out.println("哇,你是高富帅啊?");
}
if(!(A<25||B>10000)){
System.out.println("死穷逼!");
}
if(A>25&&B>10000){
System.out.println("呵呵!");
}
if(A<25&&B<10000){
System.out.println("呵呵!");
}
}
}
运算符的优先级
逻辑运算符只能对boolean类型的数据进行操作
从左到右1.() 2.[] 3.! 4.&& 5.||
public class ceshi{
public static void main(String[] args){
if(!(4>5)&&5>4||4>3){//!否定了4>5，变成肯定。
System.out.println("成立");
}
}
}
else(否则)分支
import java.util.*;
public class ceshi2{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入你的成绩");
int score=in.nextInt();
if(score>90){
System.out.println("奖励你一根棒棒糖");
}else{//如果大于90执行上面代码，否则执行下面代码
System.out.println("面壁思过");
}
}
}


多重if结构
import java.util.*;
public class ceshi0{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入你的年龄");
int A=in.nextInt();
System.out.println("请输入你的月薪");
int B=in.nextInt();
if(A<25&&B>10000){
System.out.println("哇,你是高富帅啊?");
}else if(!(A<25||B>10000)){
System.out.println("死穷逼!");
}else{
System.out.println("呵呵!");
}
嵌套if结构
import java.util.*;
public class ceshi5{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入你的性别");
String sex=in.next();
if(sex.equals("男")){//读取字符串用.equals表示
System.out.println("你的年龄是多少");
int age=in.nextInt();
if(age>18){
System.out.println("成年了啊");
}else
System.out.println("原来是个未成年啊");
}else if(sex.equals("女")){
System.out.println("原来是个女的啊");
}else
System.out.println("你在说啥?");
}
}
switch多分支结构
1.switch结构中小括号里只能出现int类型和char类型
2.case案例的个数可以随便定义但后面一定要跟常量比如case 3;case '男'
例1
import java.util.*;
public class ceshi6{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入你的名次");
int sex=in.nextInt();
switch(sex){//开关,
case 1://案例
System.out.println("出任武林盟主");
break;//跳出
case 2:
System.out.println("出任武当掌门");
break;
case 3:
System.out.println("出任峨眉掌门");
break;
default://默认
System.out.println("逐出师门");
}
}
}
例2
public class ceshi6{
public static void main(String[] args){
char A='男';
switch(A){
case '男':
System.out.println("出任武林盟主");
}
}
}
switch//开关
case //案例
break//跳出
default//默认


计算瑞年，此年能被4整除并且不能被100整除或者能被400整除的年份为瑞年，否则是平年
import java.util.*;
public class nian{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入一个年份");
int A=in.nextInt();
if(A%4==0&&A%100!=0||A%400==0){
System.out.println(A+"年是一个瑞年!");
}else
System.out.println(A+"年是一个平年!");
}
}


取随机数
方法1
导入Random
import java.util.Random;
public class suiji{
public static void main(String[] args){
Random xx=new Random();
int number=xx.nextInt(10);//取0~9的随机数
System.out.println("随机数为"+number);
}
}
方法2支持多线程
public class suiji{
public static void main(String[] args){
int number=(int)(Math.random()*10);
System.out.println(number);
}
}
猜拳游戏代码
import java.util.Scanner;
public class suiji{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("----猜拳游戏----");
System.out.println("请出拳:1.剪刀 2.石头 3.布");
int person=in.nextInt();
int computer=(int)(Math.random()*3)+1;
String Marks="出拳";
String Marks1="出拳";
switch(person){
case 1:
Marks="剪刀";
break;
case 2:
Marks="石头";
break;
case 3:
Marks="布";
break;
}
switch(computer){
case 1:
Marks1="剪刀";
break;
case 2:
Marks1="石头";
break;
case 3:
Marks1="布";
break;
}
if(person==computer){
System.out.println("你出的是:"+Marks+",电脑出的是:"+Marks1+".-_-平局!");
}else if(person==1&&computer==2||person==2&&computer==3||person==3&&computer==1){
System.out.println("你出的是:"+Marks+",电脑出的是:"+Marks1+".- -很遗憾,你输了!");
}else
System.out.println("你出的是:"+Marks+",电脑出的是:"+Marks1+".-3-恭喜,你赢了!");
}
}








循环
一元运算符：
i++;<=>i+=1<=>i=i+1//先使用后对自身加1 int i=1;int b=i++;b=1 i=2
++i;<=>i+=1<=>i=i+1//先对自身加1后使用 int r=1;int b=++r;b=2 r=2
i--;//意思和i++类似
--i;//意思和++i类似
二元运算符：
三元运算符：
if(a>100){
c=200
}else{
c=500
}
<=>等价于
int a=100
int c=a>?200:'500;


while循环
public class ceshi7{
public static void main(String[] args){
int A=1;
while(A<=10000){
System.out.println("测试!"+A);
i+=1;
}
}
}
循环三要素：
1.循环变量初始化
2.循环的判断条件
3.循环体中改变的循环变量的值
循环在哪里使用？
1.重复执行的代码
2.相近或相似的代码,其中变化的地方是有规律的
循环体里不要声明变量，不然在循环外面不起作用。
import java.util.*;
public class ceshi7{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入学生人数:");
double person=in.nextInt();
int i=1;
int sum=0;
while(i<=person){
System.out.println("请输入第"+i+"个学生的成绩:");
int a=in.nextInt();
sum=a+sum;
i++;
}
double avg=sum/person;
System.out.println((int)person+"个学生的平均成绩为:"+avg);
} 
}


while循环常见问题
永远都不会退出的循环称为死循环
如果一开始条件就不满足,while循环一次都不会执行
do-while 先执行后判断
while 先判断后执行


do-while循环
import java.util.*;
public class ceshi8{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入学生人数:");
double person=in.nextInt();
int i=1;
int sum=0;
do{
System.out.println("请输入第"+i+"个学生的成绩:");
int a=in.nextInt();
sum=a+sum;
i++;
}while(i<=person);
double avg=sum/person;
System.out.println((int)person+"个学生的平均成绩为:"+avg);
} 
}


猜数字游戏
import java.util.*;
public class ceshi8{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
Random MyRandom=new Random();
int A=MyRandom.nextInt(101);//0~100.也可以换成int A=(int)(Math.random()*101);
int number;
do{
System.out.println("请猜一下电脑随机生成的数为多少?(0-100)");
number=in.nextInt();
if(number System.out.println("猜小了!");
}else if(number>A){
System.out.println("猜大了!");
}
}while(number!=A);
*/
System.out.println("恭喜你,猜对了!");
} 
}


for循环
for(参数初始化;条件判断;更新循环变量){
循环操作;
}
循环次数固定的时候使用，比while简洁
例1
import java.util.*;
public class ceshi9{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int sum=0;
for(int j=0;i<5;j++){
System.out.println("请输入你的第"+(j+1)+"个成绩");
int score=in.nextInt();
sum=sum+score;
}
System.out.println("平均分为:"+sum/5);
}
}
例2
import java.util.*;
public class ceshi9{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入一个大于0的数:");
int A=in.nextInt();
int N=0;
if(A>0){
for(int B=1;B<=A;B++){
N=N+B;
}
System.out.println(N);
}else
System.out.println("输入的数据有错误!");
}
}
例3
import java.util.*;
public class ceshi9{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入一个整数,\n根据这个整数可以输出以下乘法表:");
int number=in.nextInt();
for(int i=1,j=number;i<=j;i++){
System.out.println(i+"*"+j+"="+(i*j));
}
}
}


让计算机随机产生100个0到100的整数，并计算平均值
import java.util.*;
public class ceshi9{
public static void main(String[] args){
Random im=new Random();
System.out.println("计算机随机产生100个0至100的数!");
int A=0;
int B=0;
double C;
for(int i=1;i<=100;i++){
A=im.nextInt(101);
B=B+A;
System.out.println("第"+i+"个随机数为:"+A);
}
C=B/100.0;
System.out.println("这100个数的平均值为:"+C);
}
}


可以用break跳出循环//可用于switch结构和循环结构
import java.util.*;
public class ceshi10{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
for(;;){
System.out.println("你爱我吗?");
String A=in.next();
if(A.equals("爱")){
break;
}
}
}
}


continue语句
只能用在循环里，
作用：跳过循环体中剩余的语句而执行下一次循环
import java.util.*;
public class ceshi10{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
while(true){
System.out.println("请输入你的密码:");
int password=in.nextInt();
if(password!=123456){
continue;//后面的循环结构里的代码被跳过
}
break;
}
System.out.println("密码正确!");
}
}


循环嵌套
循环之间可以随意互相嵌套。//for do-while while 循环
import java.util.*;
public class ceshi11{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入密码:");
int A=in.nextInt();
System.out.println("请输入循环次数:");
int D=in.nextInt();
int B=1;
while(B<=D){
int C=1;
System.out.println(B);
while(C<=2){
System.out.println("第"+C+"次内循环!");
C++;
}
B++;
if(A==123456){
continue;
}
break;
}
if(A!=123456){
System.out.println("密码错了,所以不管你想循环多少次,它只循环一次!");
}
}
}


九九乘法表
public class ceshi12{
public static void main(String[] args){
for(int A=1;A<=9;A++){
for(int B=1;B<=A;B++){
System.out.print(B+"*"+A+"="+A*B+"\t");
}
System.out.println();
}
}
}
日历
import java.util.*;
public class Test1{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入年份:");
int year=in.nextInt();
System.out.println("请输入月份:");
int month=in.nextInt();
System.out.println("\t\t\t"+year+"年"+month+"月");
int sum=1;
int days=0;
if(month==2){
if(year%4==0&&year%100!=0||year%400==0){
days=29;
}else{
days=28;
}
}else if(month==1||month==3||month==5||month==6||month==8||month==10||month==12){
days=31;
}else{
days=30;
}
for(int i=1900;i if(i%4==0&&i%100!=0||i%400==0){
sum+=366;
}else
sum+=365;
}
for(int i=1;i if(i==2){
if(year%4==0&&year%100!=0||year%400==0){
sum+=29;
}else
sum+=28;
}else if(i==4||i==9||i==7||i==11){
sum+=30;
}else
sum+=31;
}
int wekday=sum%7;
System.out.println("日\t一\t二\t三\t四\t五\t六");
for(int i=1;i<=wekday;i++){
System.out.print("\t");
}
for(int i=1;i<=days;i++){
if(sum%7==6){
System.out.print(i+"\n");
}else{
System.out.print(i+"\t");
}
sum++;
}
}
}


JVM java虚拟机
1.栈区（stacksegment）存放函数的参数值，局部变量的值等，在超过这个变量的作用域时就会被系统自动释放掉存在于JVM内存中的资源
优点：存取速度比堆快
缺点：存在栈中的数据大小与生存期必须是确定的，无灵活性


2.堆区(heapsegment)存放由new创建的对象和数组，JVM不定时查看这个对象，如果没有引入指向这个对象就回收。
优点：可以动态分配JVM内存
缺点：要在运行时分配JVM 速度慢
3.静态区
4.代码区


数组
1.数据类型  数组名[];
int arr[]=new int[1];
arr[0]=1;
2.数据类型[] 数组名;
int[] arr=new int[1];
arr[0]=1;
边声明边赋值
int[] score={89,3,123};//更简单
int[] score=new int[]{123,23,5};


数组类型
char int double Scanner Random


数组的储存原理
null  空的
String类型只声明不赋值默认为null


键盘录入赋值
import java.util.*;
public class ceshi13{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int[] arr=new int[5];
int sum=0;
for(int i=0;i<5;i++){
System.out.println("请输入第"+(i+1)+"名学生的成绩:");
arr[i]=in.nextInt();
sum+=arr[i];
}
System.out.println("5个学生的平均分为:"+sum/5);
}
}


数组的length属性
arr.length//数组长度
import java.util.*;
public class ceshi14{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入学生人数:");
int renshu=in.nextInt();
int sum=0;
int[] arr=new int[renshu];
for(int i=0;i System.out.println("请输入第"+(i+1)+"名学生的成绩:");
int score=in.nextInt();
arr[i]=score;
sum+=arr[i];
}
System.out.println(arr.length+"个学生的平均分为:"+sum/arr.length);
}
}


数组求最大值
import java.util.*;
public class ceshi14{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入学生人数:");
int renshu=in.nextInt();
int sum=0;
int[] arr=new int[renshu];
for(int i=0;i System.out.println("请输入第"+(i+1)+"名学生的成绩:");
int score=in.nextInt();
arr[i]=score;
sum+=arr[i];
}
int max=arr[0];
for(int i=0;i if(max max=arr[i];
}
}
System.out.println(arr.length+"个数中的最大值为:"+max);
}
}


数组的排序
导入java.util.Arrays类
Arrays类提供许多方法操纵数组,例如：排序，查询
Arrays类的sort()方法：对数组进行升序排列：
Arrays.sort(数组名);
import java.util.*;
public class java1 {
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int[] arr=new int[10];
for(int i=0;i System.out.println("请输入第"+(i+1)+"学生的成绩");
arr[i]=in.nextInt();
}
Arrays.sort(arr);
for(int i=0;i System.out.println(arr[i]);
}
}
}


数组的逆排序
import java.util.*;
public class java1 {
public static void main(String[] args){
Scanner in=new Scanner(System.in);
String[] arr=new String[7];
for(int i=0;i System.out.println("请输入第"+(i+1)+"个字符");
arr[i]=in.next();
}
Arrays.sort(arr);
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
}
}


数组的复制
int[] arrA={1,2,3,4,5,6,7,8};
int[] arrB=new int[arrA.length];
for(int i=0;i arrB[i]=arrA[i];
}
for(int i=0;i System.out.print(arrB[i]);
}
数组查找算法
Scanner in=new Scanner(System.in);
System.out.println("请输入你要找的学生的姓名:");
String name=in.next();
String[] arr={"张三","李四","王二","麻子","壁虎"};
boolean flag=false;
for(int i=0;i if(name.equals(arr[i])){
flag=true;
break;
}
}
if(flag==true){
System.out.println("找到了");
}else{
System.out.println("没有");


数组插入算法
Scanner in=new Scanner(System.in);
System.out.println("请输入你要插入的数据:");
int num=in.nextInt();
int[] arr={23,40,67,86};
arr[arr.length-1]=num;
for(int i=arr.length-1;i>0;i--){
if(arr[i] int t=arr[i];
arr[i]=arr[i-1];
arr[i-1]=t;
}else{
break;
}
}
for(int i=0;i System.out.println(arr[i]);
}


数组冒泡排序//每次比较一遍
public class ceshi15{
public static void main(String[] args){
int[] sum={12,54,3,234,74,23};
for(int j=0;j for(int i=0;i if(sum[i]>sum[i+1]){
int t=sum[i];
sum[i]=sum[i+1];
sum[i+1]=t;
}
}
}
for(int i=0;i System.out.println(sum[i]);
}
}
}


数组选择排序//比较之后剔除比较完的，剩下的继续比较
public class ceshi15{
public static void main(String[] args){
int[] arr={23,5,234,65,86,97,143};
for(int i=0;i for(int j=i+1;j if(arr[i]>arr[j]){
int t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
for(int i=0;i System.out.println(arr[i]);
}
}
}
多维数组(二维数组)//数组的数组
int[][] arr=new int[3][];
arr[0]=new int[3];
arr[1]=new int[2];
arr[2]=new int[5];
arr[0][1]=8;
声明一个二维数组，3行2列，循环输入6个人姓名，并循环输出。格式“
XX XX
XX XX
XX XX


代码
import java.util.*;
public class ceshi15{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
String[][] arr=new String[3][2];
int A=1;
for(int i=0;i for(int j=0;j System.out.println("请输入第"+A+"个人的姓名:");
String name=in.next();
arr[i][j]=name;
A++;
}
}
for(int i=0;i for(int j=0;j if(j==arr[i].length-1){
System.out.print(arr[i][j]+"\n");
}else{
System.out.print(arr[i][j]+"\t");
}
}
}
}
}


学生成绩管理系统
import java.util.*;
public class ceshi15{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("请输入学生的人数:");
int renshu=in.nextInt();//存储学生的人数
System.out.println("请输入课程的数目:");
int courseNum=in.nextInt();//存储课程的数目
String[] name=new String[renshu];//声明一个数组来存储学生姓名
String[] course=new String[courseNum];//声明一个数组存储课程名称
int[][] number=new int[renshu][courseNum];
int[] sum=new int[renshu];
int[] avg=new int[renshu];
String[] str=new String[renshu];
/*
用来循环存储课程的名字
*/
for(int i=0;i System.out.println("请定义第"+(i+1)+"门课程的名字");
course[i]=in.next();
}
/*
用来循环录入学生的各科成绩
*/
for(int i=0;i int S=0;
System.out.println("请输入学生的姓名:");
name[i]=in.next();//用来存储学生姓名
String str11="";
for(int j=0;j System.out.println("请输入"+name[i]+"的"+course[j]+"成绩");
number[i][j]=in.nextInt();//用来存储特定学生的特定成绩
S+=number[i][j];
str11+=number[i][j]+"\t";//输出结果为:成绩\t成绩\t
}
sum[i]=S;
avg[i]=S/courseNum;
str[i]=name[i]+"\t"+str11+sum[i]+"\t"+avg[i];
}
for(int i=0;i for(int j=0;j if(sum[j] int t=sum[j]; String t2=str[j];
sum[j]=sum[j+1];str[j]=str[j+1];
sum[j+1]=t; str[j+1]=t2;
}
}
}
System.out.print("学生");
for(int i=0;i System.out.print("\t"+course[i]);
}
System.out.print("\t总分"+"\t平均分"+"\t排行榜");
System.out.println();
for(int i=0;i System.out.println(str[i]+"\t第"+(i+1)+"名");
}
}
}


内存的分析
1：Load到内存区
2：找到main方法开始执行
3：执行过程中的内存管理：
heap(相当于堆内存)：new出来的东西
stack(相当于栈内存)：局部变量
data segment：静态变量，字符串变量
code segment：存放代码
局部变量声明在哪个大括号里，哪个大括号里就可以访问那个局部变量。


创建类和对象
命名规范：类的首字母大写，成员名小写
使用对象的的属性：方法名+点(.)+成员变量  (MyPerson.name)
访问方法名:MyPerson.eat();//eat是方法名
同一个类的每个对象有不同的成员变量的存储空间；
同一个类的每个对象共享该类的方法。
对某个属性进行取值用get，赋值用set，这是规则。
return:返回
类1
public class Person{
String name;//成员变量
String gender;//成员变量。Person的属性
int age;//成员变量
/*
无参无返回  方法
*/
public void eat(){//方法名为eat
System.out.println("我在吃饭");
}
/*
有参无返回
*/
public void slee(String A){//定义String类型的参数 名为A
System.out.println("我在"+A+"睡觉");
}
/*
有参有返回
*/
public int getAge(int a){//public后面的类型名是return返回的类型
return a;//返回给int
}
}




类2
public class A2{
public static void main(String[] args){
Person MyPerson=new Person();//创建的类名是Person，创建一个Person类的对象，并取名MyPerson
MyPerson.name="小明";//给MyPerson里名为name的String字符串赋值
System.out.println(MyPerson.name);//输出Person类中的的String字符串
MyPerson.eat();//输出Person类中的eat方法中的代码
Person Two=new Person();//创建一个Person类的对象，名为Two
System.out.println(Two.age); //输出该对象内的age的数据
Person per=new Person();
per.slee("床上");//给String A赋值并输出方法slee中的代码
int age=per.getAge(18);//给getAge的参数int a赋值18并返回(赋值)到age
System.out.println(age);
}
}


成员变量
类型:  默认值
byte 0
short 0
int 0
long 0L
char '\u0000'
float 0.0F
double 0.0D
boolean false
所有引用类型: null


return关键字
返回方法指定类型的值(这个值总是确定的)
结束方法的执行(仅仅一个return语句)
可以当做输出且能返回的语句。
class Dog{
String name;
public String print(String n,int a,char b){//可以允许多个参数,用逗号隔开，称为形参
System.out.println("n"+n);
System.out.println("a"+a);
System.out.println("b"+b);
return n;
}
public void str(int a){
if(a==0){
System.out.println("你好");
}else if(a==1){
return;//结束方法 不会输出"我很好"
}
System.out.println("我很好");
}
}
public class A4{//几个类中只能有一个public
public static void main(String[] args){
Dog A=new Dog();
//String name=A.print("小明");//给方法print中String类型A赋值并返回到name
//System.out.println(name);//取最近的类输出
//A.str(0);
A.print("小明",12,'男');//按顺序传,用逗号隔开，称为实参
}
}


例如
class Man{
String name;
int age;
char xb;
int sg;
public void playing(){
System.out.println("正在玩耍");
}
public void think(String A,String B){
System.out.println(A+B);
}
public String getEat(String C){
System.out.println(C);
return C;
}
}
public class Test{
public static void main(String[] args){
Man One=new Man();
Man Two=new Man();
One.name="小明";
Two.name="小方";
System.out.println(One.name+"\n"+Two.name);
One.playing();
Two.playing();
One.think("正在","思考");
String A=One.getEat("正在吃");
System.out.println(A);//一共输出小明 小方 正在玩耍 正在玩耍 正在思考 正在吃 正在吃
}
}


toString
在java中，所有对象都有toString()这个方法
创建类时没有定义toString方法输出对象时会输出对象的哈希码值
它通常只是为了方便输出，比如System.out.println(xx),括号里的"xx"如果不是String类型的话，就自动调用xx的toString()方法
它只是sun公司开发java的时候为了方便所有类的字符串操作而特意加入的一个方法
class Cat{
String name;
int age;
public String toString(){
return "我的姓名:"+name+"我的年龄:"+age;
}
}
public class Test{
public static void main(String[] args){
//String name=new String("你好");//因为在输出它的时候默认调用了toString方法
Cat One=new Cat();
One.name="小明";
One.age=12;
Cat Two=new Cat();
Two.name="小红";
Two.age=13;
//System.out.println(name.toString());
System.out.println(Two);//默认调用Cat中的toString方法
System.out.println(One);//默认调用toString也就是相当于System.out.println(One.toString());
}
}


this关键字
在类的方法定义中使用this关键字代表使用该方法的对象的引用
有时候使用this可以处理方法中成员变量和参数重名的问题
this可以看做一个变量，他的值是当前对象的引用
class Cat{
String name;
int age;
String color;
public void set(String name,int age,String color){
this.name=name;//把成员变量和参数名分开，并赋值到this
this.age=age;
this.color=color;
}
public String toString(){
return "姓名:"+name+"\t年龄:"+age+"\t颜色:"+color;
}
public Cat abc(){//返回的类型是Cat
return this;
}
}
public class A5{
public static void main(String[] args){
Cat one=new Cat();
Cat two=new Cat();
Cat three=new Cat();
one.set("第一只猫",5,"黑色");
two.set("第二只猫",6,"紫色");
three=two.abc();//和操作three=two一样(this已经被赋值)
System.out.println(one);
System.out.println(two);
System.out.println(three);
}
}


封装的概念
封装就是把不想或者不该告诉别人的东西隐藏起来，把可以告诉别人的公开。
做法:修改属性的访问权限来限制对属性的访问。并为每一个属性创建一个取值方法和赋值方法，用于对这些属性的访问。
private私有的，只能在自己的类里面访问，别的类不能访问
class Student{
private String name;
private int age;
private char gender;//隐藏gender
public void setGender(char gender){
if(gender=='男'||gender=='女'){
this.gender=gender;
}else{
System.out.println("请输入正确的性别");
}
}
public char getGender(){
return this.gender;
}
}
public class A5{
public static void main(String[] agrs){
Student one=new Student();
//one.gender='f';不能赋值
one.setGender('男');
//System.out.println(one.gender);//不能访问
System.out.println(one.getGender());//输出getGender方法
}
}


方法的重载
方法的重载是指一个类中可以定义有相同的名字,但参数不同的多个方法,
调用时会根据不同的参数列表选择对应的方法。
import java.util.Arrays;
class Student{
public void max(int a,int b){
System.out.println(a>b?a:b);//如果a大于b返回a，否则返回b
}
public void max(double a,double b){
System.out.println("第二个方法"+(a>b?a:b));
}
public void max(double a,double b,double c){//方法名一样
double max=a>b?a:b;
System.out.println("第三个方法"+(max>c?max:c));//括号确定优先级
}
}
public class A{
public static void main(String[] args){
//Student one=new Student();
//one.max(3,6);
//one.maxDouble(3.4,6.7);
//one.max(3.4,6.7);//根据不同的参数列表选择对应的方法
double[] arr={4.6,6.5,1.2,7.6,3.5};
Arrays.sort(arr);//sort也是一个重载的方法
for(int i=0;i System.out.println(arr[i]);
}
}
}


构造方法
使用new+构造方法创建一个新的对象
构造函数是定义在java类中的一个用来初始化对象的函数
构造函数与类同名且没有返回值
class Cat{
private String name;
private int age;
/*
Cat(String name,int age){//无法在构造方法加void，可以写public，无构造方法时自动增加一个无内容的构造方法
this.name=name;
this.age=age;
System.out.println("姓名:"+this.name+"年龄:"+this.age);
}
void get(){
System.out.println("我是一个普通方法");
}
*/
Cat(){


}
Cat(String name,int age){
this.name=name;
this.age=age;
}
void get(){
System.out.println(this.name);
}
}
public class A{
public static void main(String[] agrs){
//Cat one=new Cat("小花",12);
Cat one=new Cat();//自动调用无参数的方法Cat
one.get();
Cat two=new Cat("小花",2);
two.get();
}
}


学习方法
1.基本功 背程序。多敲(代码)，多写(代码)
2.坚持不懈，每天敲一下代码。
3.多积累问题。通常爱热心帮助其他人的，在这方面都是非常的强悍。
4.多看书(thinking in java)(java 编程思想)
5.温故而知新，多去温习前面学过的知识。
6.多找题目
7.多交流


约定俗成的命名规则
1.类名的首字母必须大写
2.方法和属性必须小写
3.由多个单词组成的类名或方法必须采用驼峰标识
如:类名StudentAdmin  方法或属性:studentName


学生管理系统
in.hasNextInt()//如果你输入的值是int型，就返回true，就赋值，否则就返回false，不执行任何操作
执行程序
import java.util.*;
public class Test{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("——请定义人数——");
Student[] stuArr=new Student[in.nextInt()];//创建一个对象数组，数组里面每个元素都是类的对象。就是数组里的每个元素都是一个学生
Admin adminStu=new Admin();//添加一个管理学生的对象
while(true){
System.out.println("——你要执行的功能——");
System.out.println("10.添加一个学生");
System.out.println("11.查找一个学生");
System.out.println("12.根据编号更新学生的基本信息");
System.out.println("13.根据编号删除学生");
System.out.println("14.根据编号输入学生的各门成绩");
System.out.println("15.根据某门成绩进行排序");
System.out.println("16.根据总分进行排序");
System.out.println("99.退出系统");
String number=in.next();//把int类型换成String类型时，输入不是数字类型不会报错
if(number.equals("10")){
System.out.println("请输入学生的姓名:");
String name=in.next();
System.out.println("请输入学生的年龄:");
int age=in.nextInt();
adminStu.create(name,age,stuArr);//把stuArr数组传过去，改变那个数组等于改变这个数组
}else if(number.equals("11")){
System.out.println("执行查找学生基本信息的操作");
System.out.println("请输入学生的编号进行查找:");
int on=in.nextInt();
adminStu.select(on,stuArr);//赋值学生编号和对象学生给select方法
}else if(number.equals("12")){
System.out.println("执行更新学员的基本信息");
System.out.println("请输入学生的编号:");
int on=in.nextInt();
System.out.println("请输入学生的姓名:");
String name=in.next();
System.out.println("请输入学生的年龄:");
int age=in.nextInt();
adminStu.update(on,name,age,stuArr);
}else if(number.equals("13")){
System.out.println("执行删除学生的操作");
System.out.println("请输入学生的编号:");
int on=in.nextInt();
adminStu.delete(on,stuArr);
}else if(number.equals("14")){
System.out.println("执行输入成绩操作");
System.out.println("请输入学生的编号");
int on=in.nextInt();
adminStu.input(on,stuArr);
}else if(number.equals("15")){
System.out.println("执行根据某科成绩排序操作");
System.out.println("请确定课程:1.Java 2.C# 3.Html 4.Sql");
int num=in.nextInt();
adminStu.courseSort(num,stuArr);
}else if(number.equals("16")){
System.out.println("执行根据总分排序操作");
adminStu.sumSort(stuArr);
}else if(number.equals("99")){
System.out.println("程序已结束");
//break;//跳出循环
System.exit(0);//结束程序
}
}
}
}


主程序
import java.util.*;
public class Admin{//用来管理学生的一个类
String msg="\t编号\t姓名\t年龄\tJava\tC#\tHtml\tSql\t总分\t平均分";
public void print(Student[] arr){//用来刷新数据的
System.out.println(msg);
for(int i=0;i if(arr[i]!=null){
arr[i].setSum();//每次刷新时计算并赋值总分给arr[i]里的Sum
arr[i].setAvg();
System.out.println(arr[i]);
}
}
}
public boolean exist(int on,Student stu){//判断学生是否存在
if(stu!=null){
if(stu.getOn()==on){
return true;
}else{
return false;
}
}
return false;
}
public void create(String name,int age,Student[] arr){//添加学生的方法
Student stu=new Student();
stu.setName(name);//赋值给成员变量
stu.setAge(age);
int i=this.setIndex(arr);//返回值被接收。把Admin方法的arr值赋值给setIndex方法
stu.setOn(i);
if(i==99999){
System.out.println("学生人数已到最大，不能再添加了.");
}else{
arr[i]=stu;
}
this.print(arr);//添加学生之后才能输出
}
public int setIndex(Student[] arr){//返回数组里面为空的下标
for(int i=0;i if(arr[i]==null){//判断格子有没有人
return i;
}


}
return 99999;
}
public void select(int on,Student[] arr){//查询方法
for(int i=0;i if(this.exist(on,arr[i])){
System.out.println(msg);
System.out.println(arr[i]);
return;
}
}
System.out.println("——没有这个学生的存在——");
}
public void update(int on,String name,int age,Student[] arr){//更新学员信息
for(int i=0;i if(this.exist(on,arr[i])){//默认等于true时成立
arr[i].setName(name);
arr[i].setAge(age);
System.out.println("——更新学生信息成功——");
this.print(arr);
return;
}
}
System.out.println("没有这个学生,更新信息失败");
}
public void delete(int on,Student[] arr){//删除学生
for(int i=0;i if(this.exist(on,arr[i])){
arr[i]=null;//把学生里的数值设为null,相当于删除
this.print(arr);
return;
}
}
System.out.println("您所指定编号的学生不存在");
}
public void input(int on,Student[] arr){//输入学生成绩的操作
for(int i=0;i if(this.exist(on,arr[i])){
System.out.println("请输入"+arr[i].getName()+"Java的成绩:");
Scanner in=new Scanner(System.in);
if(in.hasNextInt()){//如果你输入的值是int型，就返回true，就赋值，否则就返回false，不执行任何操作
arr[i].setJava(in.nextInt());
}
System.out.println("请输入"+arr[i].getName()+"C#的成绩:");
if(in.hasNextInt()){
arr[i].setC_shar(in.nextInt());
}
System.out.println("请输入"+arr[i].getName()+"Html的成绩:");
if(in.hasNextInt()){
arr[i].setHtml(in.nextInt());
}
System.out.println("请输入"+arr[i].getName()+"Sql的成绩:");
if(in.hasNextInt()){
arr[i].setSql(in.nextInt());
}
this.print(arr);
break;
}
}
}
public void courseSort(int num,Student[] arr){//根据指定的科目进行排序操作
if(num==1){
for(int i=0;i for(int j=i+1;j if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getJava() Student t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
}else if(num==2){
for(int i=0;i for(int j=i+1;j if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getC_shar() Student t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
}else if(num==3){
for(int i=0;i for(int j=i+1;j if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getHtml() Student t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
}else if(num==4){
for(int i=0;i for(int j=i+1;j if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getSql() Student t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
}
this.print(arr);
}
public void sumSort(Student[] arr){//根据总分进行排序
for(int i=0;i for(int j=i+1;j if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getSum() Student t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
this.print(arr);
}
}


成员变量操作程序
public class Student{
private int on;
private String name;
private int age;
private int java;
private int c_shar;
private int html;
private int sql;//封装
private int sum;
private int avg;

public void setOn(int on){
this.on=on;//赋值传递参数
}
public int getOn(){
return this.on;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return this.age;
}
public void setJava(int java){
this.java=java;
}
public int getJava(){
return this.java;
}
public void setC_shar(int c_shar){
this.c_shar=c_shar;
}
public int getC_shar(){
return this.c_shar;
}
public void setHtml(int html){
this.html=html;
}
public int getHtml(){
return this.html;
}
public void setSql(int sql){
this.sql=sql;
}
public int getSql(){
return this.sql;
}
public void setSum(){
this.sum=this.java+this.sql+this.html+this.c_shar;
}
public int getSum(){
return this.sum;
}
public void setAvg(){//不需要传参数 当前的参数相加等于avg
this.avg=this.sum/4;
}
public int getAvg(){
return this.avg;
}
public String toString(){
String msg="\t"+this.on+"\t"+this.name+"\t"+this.age+"\t"+this.java
+"\t"+this.c_shar+"\t"+this.html+"\t"+this.sql+"\t"+this.sum+"\t"+this.avg;
return msg;//输出return时输出它返回的参数
}
}


构造代码块
对象一旦建立就运行了，而且优先于构造函数(方法)执行。
每new一个对象，就先执行一次构造代码块，再执行构造函数。
作用:给对象进行初始化的。
构造代码块和构造方法的区别：
构造方法是给对应的对象进行初始化，构造代码块是给所以的对象进行统一的初始化。
构造代码块中定义的是不同对象共性的初始化内容。


public class Test{
public static void main(String[] args){
Person A=new Person();
Person B=new Person("小李");
System.out.println(A.country);
System.out.println(B.country);
}
}


class Person{
String name;
String country;//国籍
Person(){
System.out.println("我是无参构造方法");
}
Person(String name){
this.name=name;
System.out.println("我是有参构造方法");
}{
//System.out.println("我是构造代码块");
country="中国";
}
}
作业
定义一个Student类要求重载两个构造函数，然后在main方法中new两个对象，
它们分别调用不同的构造函数进行初始化，要求用构造代码块对对象中存在共性的数据进行初始化。


public class Admin{
public static void main(String[] args){
Student A=new Student("小雨",16);
Student B=new Student(17,"小画");
System.out.println(A.name+"\t"+A.age+"\t"+A.gender);
System.out.println(B.name+"\t"+B.age+"\t"+B.gender);
}
}


public class Student{
String name;
int age;
char gender;
Student(String name,int age){
this.name=name;
this.age=age;
}
Student(int age,String name){
this.name=name;
this.age=age;
}{
gender='男';
}
}


构造函数之间的调用
public class Admin{
public static void main(String[] args){
//Student A=new Student("小雨",16);
Student D=new Student("小雨");
}
}
/*
this看上去，用来区分局部变量和成员变量同名的情况
this:就是代表本类对象，this代表它所在函数所属对象的一个引用。


构造函数直接的调用只能通过this语句来完成.
构造函数之间进行调用时this语句只能出现在第一行.
初始化要先执行,如果初始化当中还有初始化,那就去执行更细节的初始化.
*/
public class Student{
String name;
int age;
Student(){
System.out.println("无参构造方法");
}
Student(String name){
this();
this.name=name;
System.out.println(545);
}
Student(String name,int age){
this(name);//调用含参数name的Student方法并赋值
this.age=age;
}
}


作业
定义一个学生类,要求三个成员变量(name,age,country)要求重载三个构造方法.
第一个对姓名进行初始化,第二个对姓名,年龄进行初始化,第三个对姓名.年龄.国际进行初始化.
为了提高代码的复用性要求通过构造函数之间的互相调用实现.
public class Admin{
public static void main(String[] args){
Student A=new Student("小雨",18,"中国");
}
}


public class Student{
String name;
int age;
String country;
Student(String name){
this.name=name;
System.out.println("构造函数1");
System.out.println(name);
}
Student(String name,int age){
this(name);
this.name=name;
this.age=age;
System.out.println("构造函数2");
System.out.println(name+"\t"+age);
}
Student(String name,int age,String country){
this(name,age);
this.name=name;
this.age=age;
this.country=country;
System.out.println("构造函数3");
System.out.println(name+"\t"+age+"\t"+country);
}
}


Static关键字
数据区(方法区,共享区)data
/*
static关键字
作用:是一个修饰符,用于修饰成员(成员变量,成员方法)
1.被Static修饰后的成员变量只有一份
2.当成员被Static修饰之后,多了一种访问方式,除了可以对象调用之外,
还可以被类直接调用.(Student.country)(类名.静态成员)


Static的特点
1.随着类的加载而被加载
2.优先于对象的存在
3.被所有的对象所共享的
4.可以直接被类名所调用


存放位置
类变量随着类的加载而存在于data内存区
实例变量随着对象的建立而存在于堆内存


生命周期:
1.类变量(静态变量)生命周期最长,随着类的消失而消失.
2.实例变量(非静态成员变量)生命比类变量短,它是随着对象的消失而消失.


方法注意事项:
1.静态的方法只能访问静态的成员
2.非静态的方法既能访问静态的成员(成员变量,成员方法)也能访问非静态的成员.
3.静态的方法中是不可以定义this,super关键字,因为静态优先于对象存在所以静态方法不可以出现this.
*/
public class Test{
public static void main(String[] args){
Student A=new Student();
A.country="中国";
//A.p();
Student.print();
//System.out.println(A.country);
//Student B=new Student();
//System.out.println(B.country);
}
}
public class Student{
String name;
int age;//实例变量
static String country;//静态变量(类变量)
public static void print(){
//String AA="你好世界";Static用于修饰成员,局部变量不能被Static修饰.
//ystem.out.println(AA);
System.out.println(country);
}
public void p(){
System.out.println(name);
System.out.println(country);
}
}


静态的应用范围
/*
  什么时候使用静态
static所修饰的内容是成员(成员变量,方法)
从两方面入手:
什么时候使用静态的成员变量:
当属于同一个类的所有对象出现共享数据时,
需要将存储这个共享数据的成员变量用static修饰


什么时候使用静态方法:
当功能内部没有访问到非静态的成员时(对象特有的数据)
那么该功能可以定义成静态的
*/
public class Test{
public static void main(String[] args){
Person A=new Person();
A.name="刘翔";
A.country="中国";
Person B=new Person();
B.name="姚明";
//System.out.print(B.country);
//Person.print();
A.print();
B.print();
}
}


public class Person{
String name;
static String country;
public void print(){
System.out.println(name+"你好");
}
}


main方法
/*
1.public (访问修饰符，公共的)代表该类或者该函数访问权限是最大的 
2.static 代表主函数随着类的加载就已经存在了
3.void   代表主函数没有具体的返回值
4.main   main不是java中的关键字，它是一个特殊的单词，它能够被JVM（java虚拟机）所识别。
5.String[] agrs 函数的参数，参数类型是一个字符串数组，该数组的元素字符串
*/
public class Test {
public static void main(String[] args){

System.out.println(args[0]);//会输出我是壁虎
}
}


在CMD里加载java文件：
java Test(空格) 我是壁虎(0下标) 51自学网(1下标)


静态工具类
/*
静态工具类
每一个应用程序都有共性的功能，可以讲这些功能进行抽取，独立封装。以使复用
对象的作用：对象是用来封装数据的,只要这个类里面有非静态的成员时，
那对象就必须存在
*/
public class Test{
public static void main(String[] agrs){
int[] arr={232,43,535,343,23,43,3,4};
int[] arr1={34,43,232,34344};
System.out.println(Array.max(arr1));
}
}
public class Array {
private Array(){//封装Array，使它不能创建对象

}
public static int max(int[] arr){
int max=arr[0];
for(int i=0;i if(arr[i]>max){
max=arr[i];
}
}
return max;
}
public static int min(int[] arr){//求最小值
int min=arr[0];
for(int i=0;i if(arr[i] min=arr[i];
}
}
return min;
}
}


classpath
path:主要功能是设置JDK的可执行命令
classpath:主要是在执行的时候起作用，告诉JVM类的所保存的路径
在CMD输入：
set classpath=E:\java(在这个目录找class文件)
set classpath=.(点，在当前目录找class文件)
set classpath=.;(分号隔开)E:\java(在当前目录和E盘目录找，也可以用分号隔开多个目录)
以上只对本次CMD窗口有效
在系统属性、高级、环境变量、创建classpath环境变量，设置set classpath=.;E:\java
讲永久有效


Java文档注释
注释后打开文件夹里的index.html
注释要写在方法的上方,并且每个参数都要注释
创建注释文件时输入javadoc -d Mydoc -author -version Array(文件名).java
里面只需要输入-author -version  这两个即可
/*
文档注释 文档标识符
在CMD输入javadoc -d Mydoc -author (空格)-version Array.java
*/
/**
此类是对数组进行取最值，排序等操作的
@author 张三(作者)
@version 1.0  (版本)
@param arr参数
 */
public class Array {
private Array(){//封装Array的构造器，使它不能在文档中显示

}
/**
* 取int数组里面的最大值
* @param arr 传入一个int数组
* @return 返回一个int数值
* */
public static int max(int[] arr){
int max=arr[0];
for(int i=0;i if(arr[i]>max){
max=arr[i];
}
}
return max;
}
/**
* 取int数组里面的最小值
* @param arr 传入一个int数组
* @return 返回一个int数值
* */
public static int min(int[] arr){//求最小值
int min=arr[0];
for(int i=0;i if(arr[i] min=arr[i];
}
}
return min;
}
/**
* 对传入的int数组进行冒泡排序
* @param arr 传入一个int数组
* */
public static void maoSort(int[] arr){
for(int i=0;i for(int j=0;j replace(arr,j,j+1);
}
}
} /**
* 对传入的int数组进行选择排序
* @param arr 传入一个int数组
* */
public static void xuanzeSort(int[] arr){
for(int i=0;i for(int j=i+1;j replace(arr,i,j);
}
}
}
private static void replace(int[] arr,int a,int b){//用private标识过的方法不能注释
if(arr[a]>arr[b]){
int t=arr[a];
arr[a]=arr[b];
arr[b]=t;
}
}
}




静态代码块
格式:
Static{
静态代码块中的执行语句
}
特点: 随着类的加载而执行,并且只会执行一次,并且还优先于主函数
作用:用于给类进行初始化
class Person{//加载类执行静态代码块
static{
System.out.println("我是静态代码块");
}{
System.out.println("我是构造代码块");
}
}
class Test2 {
public static void main(String[] args){
new Person();//创建对象执行构造代码块
new Person();
System.out.println("我是主函数");
}
}


对象初始化过程
1.因为我们new Student()用到了Student类,所以会把它从硬盘上加载进入内存
2..如果有Static静态代码块就会随着类的加载而执行,
还有静态成员和普通方法也会随着类的加载而被加载
3.在堆中开辟空间,分配内存地址
4.在堆中建立对象特有属性,并同时对特有属性进行默认初始化
5.对属性进行显示初始化
6.执行构造代码块,对所有对象进行初始化
7.执行对应的构造函数,对对象进行初始化
8.将内存地址给S(给栈中的变量)


设计模式:针对此类问题最有效的解决方法
java23种设计模式
单例设计模式:解决一个类只在内存中存在一个对象


如何让一个类在内存中只存在一个对象?
1.禁止其他的应用程序,通过此类来创建对象
2.既然外部不能通过此类创建对象了,我们要用对象,就可以在本类里面创建本类对象
3.为了其他应用程序能够访问到本类里面创建的对象,我需要对外界提供一种访问方式


如何用代码体现出来:
1.私有化构造方法
2.在本类中创建本类对象
3.对外界提供访问的方法
class Person{
String name;
private Person(){}//封装类
static Person p=new Person();
public static Person getInstance(){
return p;
}
}
class Test{
public static void main(String[] agrs){
Person A=Person.getInstance();//返回对象p给A,即A和p指向同一对象
A.name=("小明");
Person B=Person.getInstance();//返回对象p给B,即B和p指向同一对象
System.out.println(B.name);//输出小明
}
}


继承概述
extends:继承
继承的概述:
1.提高了代码的复用性，简化了代码
2.让类与类之间产生了继承关系，才有了多面的多态特性的存在
注意:千万不要为了获取其他类的功能简化代码，而建立继承关系，
必须要类与类之间存在继承关系，继承关系:is a


子类有父类的成员，子类不能拥有父类中被private修饰后的成员


java多层继承 在多层继承中最下层的子类拥有整个继承体系的成员，
最上层的父类里面定义所有子类共性的描述


java中不支持多继承，只支持单继承，因为多继承存在安全隐患，当多个父类定义了相同的成员，
当子类对象不确定运行哪一个。


java保留这种机制，并用了另一种方式来体现 多实现
//父类，超类，基类
class Mammal{
String buru="哺乳";
}
class MaoKe extends Mammal{
String color;
void eat(){
System.out.println("get eat");
}
}
//子类,导出类
class Cat extends MaoKe{
void CatchMouse(){
System.out.println("捕鼠");
}
}
class eopard extends MaoKe{
void run(){
System.out.println("奔跑");
}
}
class Test{
public static void main(String[] args){
Cat cat=new Cat();
cat.eat();
System.out.println(cat.buru);
}
}


子父类中的函数/子父类中的成员变量
子父类成员特点
成员：
1.成员变量
2.函数
3.构造函数


变量:
this 代表当前对象的引用 this.变量 首先在本类中找所需要的这个变量 如果没有找到再去父类中找
super 用于访问当前对象的父类成员 super.变量 直接在父类中找所需变量


/*


当子类中出现和父类中一样的函数时，当子类对象调用该函数，
运行的是子类中的函数，如同父类中的函数被覆盖了一样，
这种情况就是函数的另一种特性：重写（覆盖）


注意：
1.子类覆盖父类时，必须要保证子类权限大于等于父类，才可以覆盖，否则编译出错


访问权限修饰符：public>default>private 成员前面没加任何访问权限修饰符默认权限就是default


2.静态的函数只能覆盖静态的


记住：
重载：只看同名的方法的参数列表
重写：子父类中方法要一模一样
*/


class Animal{
String Type;
void run(){
System.out.println("跑步中");
}
}
class Cat extends Animal{


}
class Dog extends Animal{
void run(){//参数要和父类一模一样
Type="大黄狗";
System.out.println(Type+"哼着歌跑步中");
}
}
public class Test{
public static void main(String[] args){
Cat C=new Cat();
C.run();//输出跑步中
Dog d=new Dog();
d.run();//输出大黄狗哼着歌跑步中
}
}


继承中的构造函数
/*
有了子父类之后构造函数的特点:
在对子类对象进行初始化的时候
父类的构造方法也会运行,那是因为子类的构造函数默认第一行有一条隐式的语句super();
子类每个构造方法第一行都有一个隐式的super();
*/
class fu{
String name;
fu(){
System.out.println("父类构造方法");//构造方法不能被重写
}
fu(String n){
this.name=n;
System.out.println("父类有参构造方法");
}
}
class zi extends fu{
zi(){
super();
System.out.println("子类构造方法");
}
zi(String n){
super("小明");//调用父类的有参构造方法,必须写在子类的第一行
this.name="小李";
System.out.println("子类有参构造方法");
}
}
class Test2{
public static void main(String[] args){
zi zi=new zi("小李");
}
}
/*
 * 对象的转型:
 * 1.对象的向上转型 子类转成父类 默认进行 父类引用指向子类对象
 * 2.对象的向下转型 父类转成子类 强制进行
 * 关键字:instanceof 测试左边的对象是否是右边类的实例 如果是返回true不是返回false
 */
class Animal{
void sleep(){
System.out.println("睡觉中");
}
}
class Cat extends Animal{
void catchMouse(){
System.out.println("捕鼠");
}
}
class Dog extends Animal{

}
class Test3{
public static void main(String[] agrs){
Animal a=new Cat();//向上转型,只能看见子类中父类中的东西
//System.out.println(a instanceof Cat);
//Cat c=(Cat)a;//向下转型,可以访问子类和父类的成员
//c.sleep();
//Dog d=(Dog)a;//不能这样做,new的是Cat 不能给Dog
}
}
/*
多态概述
OOP三大特性：封装，继承，多态
多态：可以理解为事物存在的多种体现形态
动物：猫，狗，猪
人：男人，女人


1.多态的体现
父类引用指向子类对象
2.多态的前提
(1)必须得类与类之间存在关系，可以是继承关系，也可以是实现关系(接口里的)
(2)必须得有重写
3.多态的好处
大大提高了程序的可扩展性
4.多态的弊端
提高了程序的可扩展性，只能用父类的引用，访问到父类的中的成员


多态成员变量的特点：
1.编译期间：参阅的是引用型变量所属的类中是否有调用的方法
2.运行期间：参阅对象所属的类中是否有调用的方法
*/
class Animal{
void sing(){
System.out.println("唱歌");
}
}
class Dog extends Animal{
void sing(){
System.out.println("汪汪的唱歌");
}

}
class Cat extends Animal{
void sing(){
System.out.println("喵喵的唱歌");
}
void catchMouse(){
System.out.println("捕鼠");
}
}
class Test{
public static void main(String[] args){
Cat c=new Cat();
function(c);
Dog d=new Dog();
function(d);

}
public static void function(Animal c){//Animal c=new Cat();
//Cat c=(Cat)c;//向下转型，可以访问到子类和父类中的成员
c.sing();
}

}


多态练习
import java.util.Random;
class FK{
void bx(){
System.out.println("变形");;
}
}
class FK_szx extends FK{//山字型
void bx(){
System.out.println("山字型在变形");
}
}
class FK_lzx extends FK{//L字型
void bx(){
System.out.println("L字型在变形");
}
}
class FK_zzx extends FK{//Z字型
void bx(){
System.out.println("Z字型在变形");
}
}
class FK_cfx extends FK{//长方形
void bx(){
System.out.println("长方形在变形");
}
}
class FK_tzx extends FK{//
void bx(){
System.out.println("田字形在变形");
}
}
class Array{
public static void main(String[] args){
Random r=new Random();
FK fk=null;
int a=r.nextInt(5);
switch(a){//父类引用指向子类对象，只能访问到子类中父类的成员
case 0:
fk=new FK_szx();
break;
case 1:
fk=new FK_lzx();
break;
case 2:
fk=new FK_zzx();
break;
case 3:
fk=new FK_cfx();
break;
case 4:
fk=new FK_tzx();
break;
}
fk.bx();//调用子类中父类的成员
}
}


/*
匿名对象：没有名字的对象
匿名对象的使用方式之一：当对对象的方法只调用一次时，我们可以用匿名对象来完成，比较简化。
匿名对象的使用方式之二：匿名对象可以被当做实参传递
*/
class Car{
String color;
void start(){
System.out.println("汽车被开动");
}

}
class Test{
public static void main(String[] args){
print(new Car);
}
static void print(Car c){//Car c=new Car();
c.start();
}
}
Object类toString()
/*
一个特殊的类
Object：它是java中所有对象的直接或间接父类，根父类(基类),它里面定义的功能是所有对象都应该具备的


记住：当定义一个新类时，没有指明要继承某类，它默认继承Object类
*/
class Animal{

}
class Cat extends Animal{
public String toString(){
return "ff";
}
}
class Test{
public static void main(String[] args){
Cat c=new Cat();
System.out.println(c);
}
}
Object类equals()
/*
==和Object里面的equals其实比较的就是两对象的内存地址是否一致


*/
class Cat{
int num;
public boolean ff(Object f){//Object f=new Cat();
if(f instanceof Cat){
Cat c=(Cat)f;
return this.num==c.num;//this相当于当前对象的引用
}
return false;
}
}
class Dog{

}
class Person{


}
class Test{
public static void main(String[] args){
//Cat c=new Cat();
//Dog d=new Dog();
//System.out.println(c.ff(new Person()));
//Cat c2=new Cat();
//System.out.println(c.ff(c2));
System.out.println("ff".equals("ff"));
}
}
final关键字
/*
final(最终)是一个修饰符
1.final可以修饰类，函数，变量(成员变量，局部变量)
2.被final修饰后的类不可以被其他类继承
3.被final修饰后的函数不可以被重写
4.被final修饰后的变量不允许被再次赋值，final在对变量进行修饰时一定要赋值,
  被final修饰后的变量我们称它为常量(局部变量和成员变量都一样)


注意：常量的命名规范：字母全部要大写，如果这个名字是由多个单词组成，在单词之间用_(下划线)隔开
*/
class Person{
public static final String STUDENT_NAME="方法";//被public、static和final修饰后的变量称为全局常量
final void show(){
System.out.println("Hello");
}
void show1(){
System.out.println("Hi");
}
}
class Student extends Person{
//void show(){
// System.out.println("Hello World");错误的重写
//}
void show1(){
System.out.println("Hello Sun");
}
}
public class Test{
public static void main(String[] args){
final int A=2;
Student s=new Student();
s.show1();
Student s1=new Student();
//s.name="Jone";错误的赋值
}
}
抽象类
/*
abstract：是一个修饰符
可以修饰方法，类
1.当我们多个类存在相同的功能，但是但是功能的主体不同，这时我们进行向上抽取，
只抽取功能的定义，不抽取功能的主体。


抽象类的特点：
1.抽象方法一定要在抽象类中
2.抽象类和抽象方法必须要被abstract关键字修饰
3.抽象的类是不能被创建对象，因为调用抽象的方法没意义
4.抽象类中的方法要被使用，必须由子类重写抽象类中的方法，然后创建子类对象来调用
5.抽象类中可以定义非抽象的方法，有时我们需要此类不能被new关键字创建对象时，
  可以用abstract将子类变成抽象类。
6.子类如果只重写一部分的抽象方法，那么该子类还是一个抽象类，如果抽象类的方法要被使用，
  子类必须重写抽象类中的所有方法


值得注意：抽象类和普通的类没有太大的不同。
1.抽象类无法通过new关键字创建对象
2.抽象类里面可以有抽象的方法




*/
abstract class Animal{
abstract void sing();//有抽象的方法必须有抽象的类
abstract void show();
}
class Cat extends Animal{
void sing(){
System.out.println("喵喵唱歌");
}
void show(){}
}
class Dog extends Animal{
void sing(){
System.out.println("汪汪唱歌");
}
void show(){}
}
public class Test{
public static void main(String[] args){
Animal c=new Cat();
c.sing();
}
}
模版方法设计模式
/*
需求：求一段代码运行所花费的时间
原理：结束时间-开始时间 System.currentTimeMillis();
什么是模版方法设计模式？
定义功能时，功能的一部分是确定的，而确定的部分在使用不确定的，
那么这时就得将不确定的部分暴露出去，由该子类去完成
*/
abstract class Demo{
public final void getTime(){
long start=System.currentTimeMillis();
function();
long stop=System.currentTimeMillis();
System.out.println("共花费了："+(stop-start));
}
public abstract void function();
}
class Test1 extends Demo{
public void function(){
System.out.println("方法");
}
}
class Test{//long a=1000000000 长整型
public static void main(String[] args){
Test1 d=new Test1();
d.getTime();
}
}
接口
/*
接口：初步理解，接口是一个特殊的抽象类，当抽象类中全部是抽象方法时，//接口中没有方法主体
可以通过接口的形式来体现。
class 用于定义类
interface 用于定义接口


接口中成员的格式：
1.public static final String NAME="小李";//全局常量
2.public abstract void show();//抽象方法


注意：
1.接口中只能出现public访问修饰符
2.接口不可以创建对象，因为里面有抽象方法，需要被子类实现，
子类对接口中的所有抽象方法实现后，才能够实例化，否则子类就是一个抽象类
*/
interface smoket{//接口类没有构造函数
public static final String NAME="小李";//默认加public static final abstract修饰符
int a=0;
public abstract void show();//变量加public static final 方法加public abstract 
}
class Student implements smoket{
public void show(){
System.out.println();
}
}
class Test{
public static void main(String[] args){
Student s=new Student();
s.show();
}
}
/*
java中不支持多继承，只支持单继承，因为多继承存在安全隐患，
当多个父类定义了相同的成员，当子类对象不确定运行哪一个。
java保留这种机制，并用了另一种方式来体现>>多实现


关系：
类与类之间：继承关系
接口与类之间：实现关系
接口与接口之间：继承关系
*/
interface Smoket{
public abstract void smoket();
}
interface Game extends Smoket{
//public abstract void smoket();
public abstract void computer();
}
class Student implements Game{//Game继承Smoket里的smoket方法
public void smoket(){//把父类的2个smoket方法一起重写，变成一个
System.out.println("吸烟");
}
public void computer(){
System.out.println("游戏");
}
}
public class Test{
public static void main(String[] args){
Student s=new Student();
s.smoket();
s.computer();
}
}
接口练习
/*
接口：提高了我们功能的扩展性，因为它降低了事物与事物之间的耦合性(关系紧密程度)


父类中定义的是多个类中共性的基本功能
接口中定义的是扩展功能


接口好处：
可以多实现，也就是一个类可以实现多个接口
*/
class Person{
String name;
int age;
}
interface Smoket{
public abstract void smoket();
}
class Student extends Person{

}
class Worker extends Person implements Smoket{//一个类可以继承一个类的同时实现一个接口并可以多实现
public void smoket(){
System.out.print("抽烟");
}
}
public class Test{
public static void main(String[] args){
Worker w=new Worker();
w.smoket();
}
}
作业
class Water{
void getWater(){
System.out.println("取水");
}
}
interface Equipments{
public abstract void Gl();//过滤
public abstract void Hc();//缓冲
public abstract void Jr();//加热
public abstract void Ft();//放糖
}
class Produce extends Water implements Equipments{
public void Gl(){
System.out.println("过滤");
}
public void Hc(){
System.out.println("缓冲");
}
public void Jr(){
System.out.println("加热");
}
public void Ft(){
System.out.println("放糖");
}
}
public class Test{
public static void main(String[] args){
Produce p=new Produce();
p.getWater();
p.Gl();
p.Hc();
p.Jr();
p.Ft();
}
}
包机制
/*
包(package)
什么是包呢？可以理解为文件夹
包的作用：
1.对类进行分类管理
2.给类提供了多层命名空间


注意：编译时：javac -d .(点是当前路径)(也可以e:\java) Test.java
1.类名的全称是包名.(点)类名//包名命名规范：全部小写   输出时：java (包名点上类名)demo.Test
2.定义包的语句一定要在代码的第一行
*/
package pack;//定义了包才会把包创建
class Test{
public static void main(String[] args){

}
}
包与包之间的访问权限


第一个包
package demo;//用点隔开，a包里有b包。为了使包名具备唯一性，通常用url做包名
import stu.Student;//导入stu包里的Student类.import用来导入包，可以简化类的书写.
//import stu.*;//import 中使用通配符*用于导入此包中的所有类和包.//不建议使用通配符，因为很多包中的类不用，影响效率
class Test extends Student{
public static void main(String[] args){
show();
}
}
第二个包
package stu;
public class Student{
protected static void show(){
System.out.println("输出");
}
}

/*
访问权限修饰符
public protected default private
同一个类  OK   OK    OK    OK
同一个包  OK   OK    OK
子类  OK   OK    
不同包  OK
类只能被public 和 default 访问权限修饰符修饰
当一个记事本中定义了多个类，只能出现一个public的类
类中的成员可以被以上四种访问权限修饰符修饰
*/


jar包
/*
jar包  就是java里面的压缩包
cmd:jar cvf(jar中的cvf 3个指令) Test.jar(jar包名) A B(包名，用空格隔开)(也可以是class文件：Test.class)
cmd:set classpath=.(当前目录);Test.jar(把jar包设置成classpath路径，就可以访问里面的包和类);
*/


数据的范围
byte  -128~127
short -2^15~2^15-1
int   -2^31~2^31-1
long  -2^63~2^63-1
































































































































java进阶教程
异常概述
异常处理是面向对象语言区别于面向过程语言的重要标志之一，
异常的出现，可以使我们编写的程序变得强大并且安全。
简单的说，异常是处理错误的机制。


用try...catch处理异常
try...catch是处理异常的两种方法之一，适合处理程序员可以控制和用户输入有误的情况，
以起到程序开发顺利进行和避免不必要情况的发生
import java.util.Scanner;
public class Test{
public static void main(String[] args){
int a,b,c;
Scanner sc=new Scanner(System.in);
try{//try里面放有可能出问题的代码
a=sc.nextInt();
b=sc.nextInt();
c=a%b;
System.out.println("余数为"+c);
}catch(Exception e){//try 里的代码有异常 就执行catch里面的代码
System.out.println("输入有误");
}
System.out.println("程序顺利进行中");//执行完catch里的代码后执行它下面的代码
}
}


用throws处理异常
/*
throws是处理异常的两种方法之一，它的处理方法是讲异常抛给上一级处理，如都不能处理，
最终抛给虚拟机处理，这个过程我们称为抛异常。
这种方法适合比较严重的异常和程序员无法预料或无法完全避免异常发生的情况，
以及无法处理的异常。
尽量用try...catch语句捕获异常，
*/
import java.util.Scanner;
public class Test{
public static void main(String[] args)throws Exception{//继续往上抛，抛到虚拟机 将程序正常中止
A aa=new A();
//try{
aa.a();//a类里面只要有异常就当作aa.a();有异常
//}catch(Exception e){
//System.out.println("输入有误");
//}
System.out.println("程序顺利进行中");
}
}
class A{
void a()throws Exception{//往上抛
int a,b,c;
Scanner sc=new Scanner(System.in);
a=sc.nextInt();
b=sc.nextInt();
c=a%b;
System.out.println("余数为"+c);
}
}


finally
finally语句是起到异常处理出口的作用，用在try...catch语句的最后，
无论是否出现异常(catch中的语句是否被执行)，finally中的语句都会被执行，
这样可以更好的控制程序的走向。
import java.util.Scanner;
public class Test{
public static void main(String[] args)throws Exception{
int a,b,c;
Scanner sc=new Scanner(System.in);
try{
a=sc.nextInt();
b=sc.nextInt();
c=a%b;
System.out.println("余数为"+c);
}catch(Exception e){
System.out.println("输入有误");
}finally{//能帮你进一步的管理
System.out.println("程序顺利进行中");
}
}
}


equals方法1
java中一般情况下，不可以再用==来比较是否相等的情况，而是要用equals方法来比较，
equals方法属于Object类并且不是final类型，所以任何类都可以继承并且覆盖该方法。
/*
对象之间不可以再用"=="来进行比较，
因为这样比较的是对象的内存地址，
而不是对象中的具体属性。


覆盖后的equals方法比较的不再是两个对象的内存地址，
而是根据自己的需求来决定。
本例中比较的是变量i的值，当两个对象的i都等于20，
此时两个对象的比较结果返回了true。
*/
public class Test{
public static void main(String[] args){
B b1=new B(20);
B b2=new B(20);
System.out.println(b1.equals(b2));
}
}
class B{
private int i;
B(int i){
this.i=i;
}
public boolean equals(B b2){
if(this.i==b2.i)//this.i是b1里的i
return true;
else
return false;
}
}
equals方法2
equals方法在一般情况下都需要覆盖成自己想要的方法。
而且配合多态可以实现强大的"比较"功能。
可以比较类中的任何数据，可以根据自己的需求来定义两个对象是否相等的条件。
如果要访问子类所特有的，继承之后要再次改写。
/*


*/
public class Test{
public static void main(String[] args){
B b1=new B(20);
B b2=new B(20);
System.out.println(b1.equals(b2));

C c1=new C(10);
C c2=new C(10);
System.out.println(c2.equals(c1));
}
}
class B{
private int i;


B(int i){
this.i=i;
}
public boolean equals(B b){
if(this.i==b.i)
return true;
else
return false;
}
}
class C extends B{
private int j;


C(int j){
super(j);
this.j=j;
}
public boolean equals(B b2){
C c=(C)b2;//向下转型
if(this.j==c.j)
return true;
else
return false;
}
}


帮助文档的使用
帮助文档api的使用是学习编程语言必须要掌握的，
因为任何人都不可能将一门编程语言中的所有功能全部记住，
就好像不可能将所有的汉字全部学会一样，所以我们需要查询api。
api就相当于我们查询汉字的字典一样，所以学会查询api至关重要，
我们开发过程中的大部分功能都是通过api中提供的类和方法实现的。


集合类
一、集合类的概念
集合类是一些特殊的类，专门用来存放其他类对象的"容器"。
主要是完成一些数据库和数据结构的功能。
集合类的出现，使我们的程序变得更加强大，更加简单。
二、集合类的分类
1.LIst结构集合类
2.Map结构集合类
3.Set结构集合类
4.Queue结构集合类和Queue接口


ArrayList
/*


*/
import java.util.*;
public class Test{
public static void main(String[] args){
ArrayList aa1=new ArrayList();
System.out.println("大小为"+aa1.size());//返回此列表中的元素数。
Xs xs1=new Xs("小明",15,90);
Xs xs2=new Xs("小画",14,34);
Xs xs3=new Xs("小红",13,95);
Xs xs4=new Xs("小龙",16,76);
aa1.add(xs1);// 将指定的元素添加到此列表的尾部。
aa1.add(xs2);
aa1.add(xs3);
System.out.println("大小为"+aa1.size());
aa1.remove(1);//移除此列表中指定位置上的元素。
/*
for(int i=0;i Xs tv=(Xs)aa1.get(i);//把集合类中第i个对象返回给tv并将aa1强行转换为Xs,因为ArrayList的父类是Object
System.out.println("第"+(i+1)+"个学生的姓名是"+tv.getXingming());
}
*/
aa1.add(1,xs4);//将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。 
for(int i=0;i Xs tv=(Xs)aa1.get(i);
System.out.println("第"+(i+1)+"个学生的姓名是"+tv.getXingming());
}

}
}
class Xs{
private String xingming;
private int xuehao;
private int chengji;


Xs(String xingming,int xuehao,int chengji){
this.xingming=xingming;
this.xuehao=xuehao;
this.chengji=chengji;
}
public String getXingming(){
return xingming;
}
public int getXuehao(){
return xuehao;
}
public int getChengji(){
return chengji;
}
}


食品库存管理
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Test{
public static void main(String[] args)throws Exception{
Spgl shipin=new Spgl();
BufferedReader sr=new BufferedReader(new InputStreamReader(System.in));//从键盘输入,类似导入Scanner

while(true){
System.out.println("请按提示选择以下功能:");
System.out.println("1.添加食品");
System.out.println("2.查找食品信息");
System.out.println("3.修改食品价格");
System.out.println("4.删除食品");
System.out.println("0.退出");


String str=sr.readLine();//读取一行字符串，只能赋在字符串
if(str.equals("1")){
System.out.println("请输入食品编号");
String bh=sr.readLine();
System.out.println("请输入食品名称");
String mc=sr.readLine();
System.out.println("请输入食品编号");
float jg=Float.parseFloat(sr.readLine());//强行转换float格式

Sp sp=new Sp(bh,mc,jg);
shipin.addsp(sp);
}else if(str.equals("2")){
System.out.println("请输入食品编号");
String bh=sr.readLine();
shipin.spxx(bh);
}else if(str.equals("3")){
System.out.println("");
String bh=sr.readLine();
System.out.println("请输入新的价格");
float jg=Float.parseFloat(sr.readLine());//强行转换float格式

shipin.spjg(bh,jg);
}else if(str.equals("4")){
System.out.println("请输入食品编号");
String bh=sr.readLine();
shipin.delsp(bh);
}else if(str.equals("0")){
System.out.println("再见");
System.exit(0);//程序不稳定就-1，不过默认有异常，系统小就用0
}else{
System.out.println("输入有误");
}
}
}
}
class Spgl{
private ArrayList aa=null;

Spgl(){
aa=new ArrayList();//new Spgl的时候也new ArrayList
}

public void addsp(Sp sp){
aa.add(sp);
System.out.println("添加新食品成功!");
}
public void spxx(String bh){
int i;
for(i=0;i Sp sp=(Sp)aa.get(i);
if(sp.getBianhao().equals(bh)){
System.out.println("该食品的信息为：");
System.out.println("食品编号"+bh);
System.out.println("食品名称:"+sp.getMingcheng());
System.out.println("食品价格:"+sp.getJiage());
break;
}
}
if(i==aa.size()){
System.out.println("对不起，无此食品!");
}
}
public void delsp(String bh){
int i;
if(aa.size()==0){
System.out.println("对不起，仓库中没有任何食品!");
}
for(i=0;i Sp sp=(Sp)aa.get(i);
if(sp.getBianhao().equals(bh)){
aa.remove(i);
System.out.println("删除食品成功!");
break;
}
}
if((i==aa.size())&&(aa.size()!=0)){
System.out.println("对不起，没有该食品!");
}
}
public void spjg(String bh,float jg){
int i;
for(i=0;i Sp sp=(Sp)aa.get(i);
if(sp.getBianhao().equals(bh)){
sp.setJiage(jg);
System.out.println("修改食品价格成功!");
break;
}
}
if(i==aa.size()){
System.out.println("对不起，没找到相应的食品!");
}
}
}


class Sp{
private String bianhao;
private String mingcheng;
private float jiage;

Sp(String bianhao,String mingcheng,float jiage){
this.mingcheng=mingcheng;
this.bianhao=bianhao;
this.jiage=jiage;
}

public String getBianhao(){
return bianhao;
}
public void setBianhao(String bianhao){
this.bianhao=bianhao;
}
public String getMingcheng(){
return mingcheng;
}
public void setMingcheng(String mingcheng){
this.mingcheng=mingcheng;
}
public float getJiage(){
return jiage;
}
public void setJiage(float jiage){
this.jiage=jiage;
}
}