自学java基础笔记

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


数据类型说明
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<A){
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("请输入一个整数, 根据这个整数可以输出以下乘法表:");
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+" ");
}
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(" "+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<year;i++){
if(i%4==0&&i%100!=0||i%400==0){
sum+=366;
}else
sum+=365;
}
for(int i=1;i<month;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("日 一 二 三 四 五 六");
for(int i=1;i<=wekday;i++){
System.out.print(" ");
}
for(int i=1;i<=days;i++){
if(sum%7==6){
System.out.print(i+" ");
}else{
System.out.print(i+" ");
}
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<arr.length;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<arr.length;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<arr.length;i++){
if(max<arr[i]){
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<arr.length;i++){
System.out.println("请输入第"+(i+1)+"学生的成绩");
arr[i]=in.nextInt();
}
Arrays.sort(arr);
for(int i=0;i<arr.length;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<arr.length;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<arrA.length;i++){
arrB[i]=arrA[i];
}
for(int i=0;i<arrA.length;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<arr.length;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]<arr[i-1]){
int t=arr[i];
arr[i]=arr[i-1];
arr[i-1]=t;
}else{
break;
}
}
for(int i=0;i<arr.length;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<sum.length-1;j++){
for(int i=0;i<sum.length-1;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<sum.length;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<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
for(int i=0;i<arr.length;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<arr.length;i++){
for(int j=0;j<arr[j].length;j++){
System.out.println("请输入第"+A+"个人的姓名:");
String name=in.next();
arr[i][j]=name;
A++;
}
}
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
if(j==arr[i].length-1){
System.out.print(arr[i][j]+" ");
}else{
System.out.print(arr[i][j]+" ");
}
}
}
}
}


学生成绩管理系统
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<course.length;i++){
System.out.println("请定义第"+(i+1)+"门课程的名字");
course[i]=in.next();
}
/*
用来循环录入学生的各科成绩
*/
for(int i=0;i<renshu;i++){
int S=0;
System.out.println("请输入学生的姓名:");
name[i]=in.next();//用来存储学生姓名
String str11="";
for(int j=0;j<courseNum;j++){
System.out.println("请输入"+name[i]+"的"+course[j]+"成绩");
number[i][j]=in.nextInt();//用来存储特定学生的特定成绩
S+=number[i][j];
str11+=number[i][j]+" ";//输出结果为:成绩 成绩
}
sum[i]=S;
avg[i]=S/courseNum;
str[i]=name[i]+" "+str11+sum[i]+" "+avg[i];
}
for(int i=0;i<sum.length-1;i++){
for(int j=0;j<sum.length-1;j++){
if(sum[j]<sum[j+1]){//把总成绩高的放在前面，然后交换str字符，让其他字符串和总成绩对齐
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<course.length;i++){
System.out.print(" "+course[i]);
}
System.out.print(" 总分"+" 平均分"+" 排行榜");
System.out.println();
for(int i=0;i<renshu;i++){
System.out.println(str[i]+" 第"+(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+" "+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+" 年龄:"+age+" 颜色:"+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<arr.length;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=" 编号 姓名 年龄 Java C# Html Sql 总分 平均分";
public void print(Student[] arr){//用来刷新数据的
System.out.println(msg);
for(int i=0;i<arr.length;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<arr.length;i++){
if(arr[i]==null){//判断格子有没有人
return i;
}


}
return 99999;
}
public void select(int on,Student[] arr){//查询方法
for(int i=0;i<arr.length;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<arr.length;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<arr.length;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<arr.length;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<arr.length-1;i++){//用冒泡排序会不准确
for(int j=i+1;j<arr.length;j++){
if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getJava()<arr[j].getJava()){
Student t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
}else if(num==2){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getC_shar()<arr[j].getC_shar()){
Student t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
}else if(num==3){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getHtml()<arr[j].getHtml()){
Student t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
}else if(num==4){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getSql()<arr[j].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<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]!=null&&arr[j]!=null){
if(arr[i].getSum()<arr[j].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=" "+this.on+" "+this.name+" "+this.age+" "+this.java
+" "+this.c_shar+" "+this.html+" "+this.sql+" "+this.sum+" "+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+" "+A.age+" "+A.gender);
System.out.println(B.name+" "+B.age+" "+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+" "+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+" "+age+" "+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<arr.length;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<arr.length;i++){
if(arr[i]<min){
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<arr.length;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<arr.length;i++){
if(arr[i]<min){
min=arr[i];
}
}
return min;
}
/**
* 对传入的int数组进行冒泡排序
* @param arr 传入一个int数组
* */
public static void maoSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1;j++){
replace(arr,j,j+1);
}
}
} /**
* 对传入的int数组进行选择排序
* @param arr 传入一个int数组
* */
public static void xuanzeSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;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 CatchMou