学习路线
java学习
资源：狂神说
一、基础语法
1.注释、标识符、关键字
（1） 建立空项目来建立java项目：
（2） 单行注释：//注释
（3） 多行注释：/*
Djandjan
/
（4） 文档注释: /* */
2标识符（类名，变量名，方法名）
（5） 关键字
（6） 标识符注意点：
2.数据类型
（1） 要求变量严格符合规范，所有变量先定义后使用（java, c++）
（2） 弱类型语言（js,vb）
（3） 分类 ①基本类型
②引用类型
//小数；浮点数
float num5=50.1F;
double num6=3.415926;
//字符
char name='马';
//String不是关键字，是一个类
//String name="秦疆"；
//布尔值;是非
boolean flag = true;
3.类型转换
publicclassDemo3{publicstaticvoidmain(String[] args){//整数拓展： 进制 二进制ob 十进制 八进制o 十六进制oxint i =10;int i2 =010;//八进制int i3 =0x10;//十六进制System.out.println(i);System.out.println(i2);System.out.println(i3);System.out.println("=================================");//浮点数拓展 银行业务怎么表示 BigDecimal 数学工具类//float 有限 离散 舍入误差 大约 接近但不相等//double//最好避免完全使用浮点数进行比较float f =0.1f;//0.1double d =1.0/10;//0.1System.out.println(f==d);System.out.println(f);System.out.println(d);float d1 =32423423423f;float d2 = d1+1;System.out.println(d1==d2);//字符类拓展System.out.println("==============================");char c1 ='a';char c2 ='中';System.out.println(c1);System.out.println((int)c1);//强制转换System.out.println(c2);System.out.println((int)c2);//强制换行//所有字符本质还是数字//编码 Unicode 表：97=a 65=A 2字节 0-65536 Excel//U00000-UFFFFFchar c3 ='\u0061';System.out.println(c3);//a//转义字符// \t 制表符// \n 换行//.....System.out.println("l\tl\nd");System.out.println("=========================");String sa =newString("dcfs");String sb =newString("dcfs");System.out.println("sa==sb");String sc ="qqqq";String sd ="qqqq";System.out.println(sc==sd);//对象 从内存分析//布尔值拓展boolean flag =true;if(flag==true){}if(flag){}//建议精简代码}}
publicclassDemo4{publicstaticvoidmain(String[] args){int i =128;double b = i;byte c =(byte)i;//内存溢出 -128//强制类型转换 （类型）变量名 高----低//自动转换 低-----高System.out.println(i);System.out.println(b);System.out.println(c);/*
* 注意点：
*1.不能对布尔值进行转换
*2.不能吧对象转换成不相干的数据
*3.把高容量转换成低容量的要强制转换
*4.转换时会出现内存溢出问题，或者精度问题
* */System.out.println("===============");System.out.println((int)23.7);//23System.out.println((int)-45.3);//-45System.out.println("===============");char c1 ='a';int d1 = c1+1;System.out.println((char) d1);//操作比较大的数，注意溢出问题//JDK新特性，数字之间可以用下划线分割int money =10_0000_0000;int year =20;int total1 = money*year;// -147484163,计算时已经溢出了long total2 = money*year;//默认是int,转换之前已经存在问题了long total3 = money*((long)year);//先把一个数据转换成LongSystem.out.println(total3);}}
4.变量 常量 作用域
publicclassDemo5{//属性：变量//常量 修饰符 不存在先后顺序staticfinaldoublePI=3.14;//类变量staticstaticdouble salary =2500;//实例变量：从属于对象;如果不初始化，这个类型的默认值0，0.0//布尔值：默认值是false//除了基本类型，其余默认值都是null;String name;int age;//main 方法publicstaticvoidmain(String[] args){//局部变量：必须声明和初始化,局部变量只在方法快里起作用int i =10;System.out.println(i);//变量类型 变量名字=new Demo5();Demo5 demo5 =newDemo5();System.out.println(demo5.age);System.out.println(salary);System.out.println(PI);}//其他方法publicvoidadd(){}
5.运算符
int a =10;int b =20;int c =25;int d =25;System.out.println(a+b);System.out.println(a*b);System.out.println(a-b);System.out.println(a/(double)b);//注意运算结果范围
long a =12312312312313L;int b =123;short c =8;byte d =8;System.out.println(a+b+c+d);//LongSystem.out.println(b+c+d);//IntSystem.out.println(c+(double)d);//Tnt
int a =10;int b =20;int c =21;System.out.println(a>b);System.out.println(a<b);System.out.println(a==b);System.out.println(a!=b);System.out.println(c%a);//取余 模运算
int a =10;int b =20;int c =21;System.out.println(a>b);System.out.println(a<b);System.out.println(a==b);System.out.println(a!=b);System.out.println(c%a);//取余 模运算
//++ -- 自增 自减 一元运算符int a =3;int b = a++;//"后加加"，先给b赋值，再自增// a=a+1;System.out.println(a);//a=a+1；int c =++a;//“前加加”，先自增，再给b赋值System.out.println(a);System.out.println(b);System.out.println(c);//幂运算2^3 2*2*2 = 8 使用工具类操作（Math）double pow =Math.pow(2,3);//Math.pow(2,3) Alt+EnterSystem.out.println(pow);
//与（and） 或(or) 非(and)boolean a =true;boolean b =false;System.out.println("a&&b"+(b&&a));//逻辑与运算：两个变量为真，结果才为trueSystem.out.println("a||b"+(a||b));//逻辑或运算：两个变量有一个为真，结果才为trueSystem.out.println("!(a&&b)"+(a&&b));//真->假 假->真//短路运算 c<4为false ,后面c++不执行int c =5;boolean d =(c<4)&&(c++<4);System.out.println(d);//falseSystem.out.println(c);//5
/*
* A = 0011 1100
* B = 0000 1101
* ------------------
* A&B = 0000 1100
* A|B = 0011 1101
* A^B = 0011 0001 相同为0，不同为1
* ~B = 1111 0010
*
* 2*8 = 16 2*2*2*2
* 增加效率！！！
* << *2
* << /2
* */System.out.println(2<<3);
int a =10;int b =20;
a+=b;//a=a+b
a-=b;//a=a-bSystem.out.println(a);//字符串连接符 + ，String ""+()=字符串System.out.println(""+a+b);System.out.println(a+b+"");
//x ? y : z//如果x==true, 则结果为y,否则为zint score =50;String type = score <60?"不及格":"及格";System.out.println(type);
二、Java流程控制
1.Javadoc
publicclassDoc{String name;/**
* @author kuangshen
* @version 1.0
* @since 1.11
*//**
* @author Kuangshen
* @param name
* @return
* @throws Exception
*/publicStringtest(String name)throwsException{return name;}
2.用户交互Scanner
publicclassDemo1{publicstaticvoidmain(String[] args){//创建一个扫描器对象，用于接受键盘数据Scanner scanner =newScanner(System.in);// new Scanner(System.in)+alt+EnterSystem.out.println("使用next方式接受：");//判断用户有没有输入字符串if(scanner.hasNext()){//使用Next方式接受String str = scanner.next();System.out.println("输入的内容为"+str);}//凡属于Io流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
scanner.close();}}
publicstaticvoidmain(String[] args){//创建一个扫描器对象，用于接受键盘数据Scanner scanner =newScanner(System.in);System.out.println("使用nextLine方式接受：");if(scanner.hasNextLine()){//使用Next方式接受String str = scanner.nextLine();System.out.println("输入的内容为"+str);}
scanner.close();
publicstaticvoidmain(String[] args){//创建一个扫描器对象，用于接受键盘数据Scanner scanner =newScanner(System.in);System.out.println("输入数据：");String str = scanner.nextLine();System.out.println("输入的内容为： "+str);
scanner.close();}
publicstaticvoidmain(String[] args){Scanner scanner =newScanner(System.in);//从键盘接受数据int i =0;float f =0.0f;System.out.println("请输入整数:");//如果 .... 那么if(scanner.hasNextInt()){
i = scanner.nextInt();System.out.println("整数数据为："+i);}else{System.out.println("输入的不是整数数据！");}//如果 .... 那么if(scanner.hasNextFloat()){
f = scanner.nextFloat();System.out.println("小数数据为："+i);}else{System.out.println("输入的不是小数数据！");}}
publicstaticvoidmain(String[] args){//我们可以输入多个数字，并求和与平均数，每输入一个数字用回车表示Scanner scanner =newScanner(System.in);//和double sum =0;//计算输入了多少个数字int m =0;//通过循环判断是否还存在输入，并在里面对每一次进行求和和统计while(scanner.hasNextDouble()){double x = scanner.nextDouble();//scanner.nextDouble();输入一个数
m=m+1;//m++
sum = sum +x;System.out.println("你输入了第"+m+"个数据，当前的结果sum+"+sum);}System.out.println(m+"个数的和为："+sum);System.out.println(m+"个数的平均值为："+(sum/m));
scanner.close();}
3.选择结构
1.if单选择结构
publicstaticvoidmain(String[] args){Scanner scanner =newScanner(System.in);System.out.println("请输入内容：");String s = scanner.nextLine();//equal:判断字符是否相等if(s.equals("hellow")){System.out.println(s);}System.out.println("end");
scanner.close();
2.if双选择结构
//双选择结构publicstaticvoidmain(String[] args){//考试分数大于60就是及格，小于60分就是不及格Scanner scanner =newScanner(System.in);System.out.println("输入成绩：");int score = scanner.nextInt();if(score>60){System.out.println("及格");}else{System.out.println("挂了");}
scanner.close();}
3.if多选择结构
publicstaticvoidmain(String[] args){//多选择结构Scanner scanner =newScanner(System.in);System.out.println("请输入成绩： ");int score = scanner.nextInt();if(score==100){System.out.println("满分");}elseif(score<100&& score>90){System.out.println("A");}elseif(score<90&& score>80){System.out.println("B");}elseif(score<80&& score>70){System.out.println("C");}elseif(score<70&& score>60){System.out.println("D");}elseif(score<60){System.out.println("挂了");}else{System.out.println("成绩不合法");}
scanner.close();}
4.switch选择结构
publicstaticvoidmain(String[] args){//case具有穿透性，需要break进行停止//seitch匹配一个具体的值char grade ='A';switch(grade){case'A':System.out.println("优秀");break;//可选case'B':System.out.println("良好");break;//可选case'C':System.out.println("及格");break;//可选case'D':System.out.println("挂科");break;//可选default:System.out.println("未知");}}
5.循环结构
1.while循环
publicstaticvoidmain(String[] args){//输出1~100int i =0;// System.out.println(i++);// System.out.println(i++);// System.out.println(i++);// System.out.println(i++);// System.out.println(i++);// System.out.println(i++);// System.out.println(i++);while(i<=100){
i++;System.out.println(i);}}
publicstaticvoidmain(String[] args){//死循环while(true){//等待客户检查//定时检查}}
publicstaticvoidmain(String[] args){//计算1+2+3....100=？int i =0;int sum =0;while(i<=100){
sum = sum +i;
i++;}System.out.println(sum);}
2.do…while
publicstaticvoidmain(String[] args){int i =0;int sum =0;do{
sum = sum +1;
i++;}while(i<=100);System.out.println(sum);}
publicstaticvoidmain(String[] args){//do....while至少执行一次int a =0;while(a<0){System.out.println(a);
a++;}System.out.println("===============");do{System.out.println(a);}while(a<0);}
3.for
publicstaticvoidmain(String[] args){int a =1;//初始化条件while(a<=100){//条件判断System.out.println(a);//循环体
a+=2;//迭代}System.out.println("while循环结束");//初始化//条件判断 //迭代for(int i =0; i <100; i++){System.out.println(i);}System.out.println("for循环结束！");//死循环for(;;){}}
publicstaticvoidmain(String[] args){//计算1~100之间奇数和偶数的和int oddSum =0;int evenSum =0;for(int i =0; i <100; i++){if(i%2!=0){
oddSum+= i;}else{
evenSum+=i;}}System.out.println("奇数和的"+oddSum);System.out.println("偶数和的"+evenSum);}
publicstaticvoidmain(String[] args){//用while或for循环输出1-1000之间能被5整除的数，并且每行输出三个for(int i =0; i <1000; i++){if(i%5==0){System.out.println(i+"/t");}if(i%(5*3)==0){//每行System.out.println();//System.out.print("/n");}}//pritntln 输出完全会换行//print 输出完不会换行}
publicstaticvoidmain(String[] args){//打印九九乘法表/*
* 1.我们先打印第一列
* 2.固定的1再用一个循环包起来
* 3.去掉重复项
* 4.调整样式
* */for(int j =1; j <=9; j++){for(int i =1; i <= j; i++){System.out.print(j+"*"+i+"="+j*i+"\t");}System.out.println();}}
publicstaticvoidmain(String[] args){int[] number ={10,20,30,40,50};//遍历数组for(int x:number){System.out.println(x);}System.out.println("==============");for(int i =0; i <5; i++){System.out.println(number[i]);}}
4.break、continue
publicstaticvoidmain(String[] args){int i =0;while(i<100){
i++;System.out.println(i);if(i==30){break;}}System.out.println("1,2,3");}
publicstaticvoidmain(String[] args){int i =0;while(i<100){
i++;if(i%10==0){System.out.println();continue;}System.out.print(i);System.out.print("\t");}}
1.break在任何循环语句的主题部分，均可用break控制循环流程。
2.break用于强行退出循环，不执行剩余语句。（break语句也在switch语句中使用）
3.continue语句在循环语句体中，用于终止某次循环过程，即跳出循环体中尚未执行的语句，接着执行下一次是执行循环的判定。
训练：打印三角形
publicstaticvoidmain(String[] args){for(int i =1; i <=5; i++){for(int j=5;j>=i;j--){System.out.print(" ");}for(int j=1;j<=i;j++){System.out.print("*");}for(int j=1;j<i;j++){System.out.print("*");}System.out.println();}}
三、Java方法详解
1.方法定义
（1）.方法命名规则:首字母小写，后面驼峰规则
（2）.形式：
修饰符 返回值类型 方法名（参数类型 参数名）{
方法体；
return 返回值；
}
2.方法调用
值传递
publicstaticvoidmain(String[] args){//实际参数：实际调用传递的参数int sum =add(1,2);System.out.println(sum);}//形式参数，用来定义作用publicstaticintadd(int a,int b){return a+b;}//方法重载publicstaticintadd(int a,int b,int c){return a+b+c;}
3.方法重载
相同函数名称，形参不同
publicstaticvoidmain(String[] args){int max =max(10,20);System.out.println(max);}//比大小 方法重载“名字可以相同，参数类型（个数、类型、排列顺序）不同”publicstaticdoublemax(double a,double b){double result =0;if(a == b){System.out.println("a = b");return0;//终止方法}if(a>b){
result = a;}else{
result = b;}return result;}//比大小publicstaticintmax(int a,int b){int result =0;if(a == b){System.out.println("a = b");return0;//终止方法}if(a>b){
result = a;}else{
result = b;}return result;}
4.命名行传参
5.可变参数
publicstaticvoidmain(String[] args){//调用可变参数方法printMax(12.11,21,121,1212,121);printMax(newdouble[]{1,2,3});}publicstaticvoidprintMax(double...number){if(number.length==0){System.out.println("No argument passed");return;}double result = number[0];//排序！for(int i =1; i <number.length ; i++){if(number[i]>result){
result = number[i];}}System.out.println("The max value is"+result);}
6.递归
//阶乘publicstaticvoidmain(String[] args){System.out.println(f(3));}publicstaticintf(int n){if(n==1){return n;}else{return n*f(n-1);}}
四、数组
1.定义与初始化
publicclassArrayDemo01{//变量的类型 变量的名字 = 变量的值；//数组类型publicstaticvoidmain(String[] args){int[] nums;// 1.定义一个人数组
nums =newint[10];// 2.创建一个数组//赋值for(int i =0; i <10; i++){
nums[i]= i;System.out.println("num["+i+"]="+nums[i]);}//求和//nums.length 数组长度int sum =0;for(int i =0; i < nums.length; i++){
sum = sum + nums[i];}System.out.println();System.out.println("数组和为"+sum);}}
publicstaticvoidmain(String[] args){//静态初始化：创建＋赋值int[] a ={1,2,3,4,5,6,7,8};System.out.println(a[0]);//动态初始化：包含默认初始化int[] b =newint[10];
b[0]=10;
b[1]=11;System.out.println(b[0]);System.out.println(b[1]);System.out.println(b[2]);System.out.println(b[3]);System.out.println(b[4]);System.out.println(b[5]);}
3.数组使用
publicclassArrayDemo03{publicstaticvoidmain(String[] args){int[] array ={1,2,3,4,5,6,7,8};//打印全部数组元素for(int i =0; i <array.length ; i++){System.out.println(array[i]);}System.out.println("=============");//计算机所有元素的和int sum =0;for(int i =0; i <array.length ; i++){
sum += array[i];}System.out.println("sum="+sum);System.out.println("==============");//查找最大的元素int max = array[0];for(int i =0; i <array.length ; i++){if(array[i]>max){
max = array[i];}}System.out.println("max="+max);}}
publicstaticvoidmain(String[] args){int[] arrays ={1,2,3,4,5,6};// //JDK1.5 没有下标 arrays.for// for (int array : arrays) {// System.out.println(array);// }int[] revese =revese(arrays);printArray(revese);}//打印数组元素publicstaticvoidprintArray(int[] arrays){for(int i =0; i <arrays.length ; i++){System.out.print(arrays[i]+"");}}//反转数组publicstaticint[]revese(int[] arrays){int[] result =newint[arrays.length];for(int i =0,j = arrays.length-1; i <arrays.length; i++,j--){
result[j]= arrays[i];}return result;}
publicstaticvoidmain(String[] args){//[4][2] 面向对象/*
* 1,2 array[0]
* 2,3 array[1]
* 3,4 array[2]
* 4,5 array[3]
* */int[][] array ={{1,2},{2,3},{3,4},{4,5}};for(int i =0; i <array.length ; i++){for(int j =0; j <array[i].length ; j++){System.out.println(+array[i][j]);}}}
publicstaticvoidmain(String[] args){int[] a ={15,1,1,5,61,561,561,651,561};//System.out.println(a);//打印数组// System.out.println(Arrays.toString(a));printArrray(a);System.out.println();//数组排序 升序Arrays.sort(a);System.out.println(Arrays.toString(a));System.out.println();//填充Arrays.fill(a,2,4,0);System.out.println(Arrays.toString(a));}publicstaticvoidprintArrray(int[] a){for(int i =0; i <=a.length ; i++){if(i==0){System.out.print("[");}if(i==a.length){System.out.print("]");}else{System.out.print(a[i]+",");}}}
冒泡排序
importjava.util.Arrays;publicclassArrayDemo07{publicstaticvoidmain(String[] args){int[] a ={1,222,45,564,64,4654,564,16,54,6,5,14};int[] poposort =poposort(a);System.out.println(Arrays.toString(poposort));}/*冒泡排序
*1.比较相邻元素，如果第1个数比第二个数大，交换他们的位置
*2.每一次比较，都会产生一个最大的，或者最小的数字
*3.下一次排序可以少一次排序!
*4.以此循环，直到结束
* */publicstaticint[]poposort(int[] array){//临时变量int temp=0;//外层循环，判断走了多少次for(int i =0; i <array.length ; i++){boolean flag =false;//通过Flag标志位减少无意义的比较。//内层循环，比较判断两个数，第一个数比第二的数大，则交换位置for(int j =0; j <array.length-1-i; j++){if(array[j+1]<array[j]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
flag =true;}}if(flag==false){break;}}return array;}}
4.二维数组与稀疏数组使用
publicstaticvoidmain(String[] args){//1.创建一个二维数组11*11 0：没有棋子 1：黑棋 2:白棋int[][] array1 =newint[11][11];
array1[1][2]=1;
array1[2][3]=2;//输出原始数据System.out.println("输出原始数据");for(int[] ints : array1){for(int anInt : ints){System.out.print(anInt+"\t");}System.out.println();}//转换为稀疏数组保存//获得有效值的个数int sum =0;for(int i =0; i <11; i++){for(int j =0; j <11; j++){if(array1[i][j]!=0){
sum++;}}}System.out.println("有效值的个数："+sum);//创建一个稀疏数组int[][] array2 =newint[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]= sum;//遍历二维数组，将非零值存放在稀疏数组中int count =0;for(int i =0; i <array1.length ; i++){for(int j =0; j <array1[i].length; j++){if(array1[i][j]!=0){
count++;
array2[count][0]= i;
array2[count][1]= j;
array2[count][2]= array1[i][j];}}}//输出稀疏数组System.out.println("稀疏数组");for(int i =0; i <array2.length ; i++){System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");}System.out.println("===============");System.out.println("还原");//1.读取稀疏数组int[][] array3 =newint[array2[0][0]][array2[0][1]];//2.给其中元素还原他的值for(int i =1; i <array2.length ; i++){
array3[array2[i][0]][array2[i][1]]= array2[i][2];}//3.打印for(int[] ints : array3){for(int anInt : ints){System.out.print(anInt+"\t");}System.out.println();}}
二维数组底层逻辑图：
五、面向对象编程（OPP）
1.理解及定义
2.方法定义及调用
***/*
- 修饰符 返回值类型 方法名（）{
- //方法体
- return 返回值；
- }
- /**
importjava.io.IOException;//Demo类publicclassDemo01{//main方法publicstaticvoidmain(String[] args){}/*
* 修饰符 返回值类型 方法名（）{
* //方法体
* return 返回值；
* }
* *///return 结束方法，返回一个结果publicStringsayhellow(){return"Hellow";}publicvoidprint(){return;}publicintmax(int a,int b){return a > b?a:b;//三元运算符}//数组下标越界：ArrayindexoutofboundspublicvoidreadFile(String file)throwsIOException{}}
调用方法
publicstaticvoidmain(String[] args){//调用静态方法直接用 类.方法（）；Student.say();//调用非静态方法// 1.实例化 对象类型 对象名 = 对象值；// 2.对象.方法Student student =newStudent();
student.play();//或者 new Student().play()}//和类一起加载的publicvoida(){b();}//实例化之后才存在publicvoidb(){a();}//带static不可以调用不带的}
实际参数要对应形式参数的类型
publicclassDemo03{publicstaticvoidmain(String[] args){//实际参数要对应形式参数的类型int add =Demo03.add(3,2);//实际参数System.out.println(add);}publicstaticintadd(int a,int b){//形式参数return a+b;}}
值传递
publicclassDemo04{//值传递publicstaticvoidmain(String[] args){int a =1;System.out.println(a);//a:1Demo04.chage(a);System.out.println(a);//a:1}//返回值为空publicstaticvoidchage(int a){
a =10;}}
3.类与对象的关系
引用传递
//对象、内存publicclassDemo05{publicstaticvoidmain(String[] args){Person person =newPerson();System.out.println(person.name);//nullDemo05.change(person);System.out.println(person.name);//qinyan}publicstaticvoidchange(Person person){//person是一个对象：指向的--->Person person = new Person();这是一个具体的人，可以改变属性！
person.name="qinyan";}}//定义一个Person,有一个属性：nameclassPerson{String name;//NULL}
packagecom.oop.demo01;publicclassStudent{//静态方法publicstaticvoidsay(){System.out.println("学生说话了");}//非静态方法publicvoidplay(){System.out.println("学生wan了");}}
4.创建和初始化对象
构造器
* 构造器：
* 1.与类名相同
* 2.没有返回值
*作用：
* 1.new 的本质在调用构造方法
* 2.初始化对象的值
*
* 注意：一旦定义了有参构造，若想用无参构造，无参构造必须显示！！！，否则无意义
*this.当前类 = 定义参数
//java---->classpublicclassPerson{//Person类中存在一个空的Person方法//一个类即使什么也不写，也会存在一个方法//显示构造器String name;int age;//实例化初始值//1.使用new关键字必须有构造器//2.用来初始化值publicPerson(){//无参构造this.name ="QINyan";}//有参构造：一旦定义了有参构造，无参构造必须显示，否则无意义publicPerson(String name){//无参构造this.name ="QINyan";}//alt+insert 生成构造器!!!!publicPerson(String name,int age){this.name = name;this.age = age;}}/*
* public static void main(String[] args) {
//Person类中存在一个默认的空的Person方法
Person person = new Person();
System.out.println(person.name);
}
//学生类publicclassStudent{//属性：字段String name;//默认nullint age;//方法publicvoidstudy(){System.out.println(this.name+"学习");}
测试：
publicstaticvoidmain(String[] args){//类：抽象的，实例化//类实例化后会返回一个自己的对象！//student对象就是一个Student类的具体实例！//不同的对象有相同的属性，可以给对象的属性赋不同的值Student student =newStudent();Student student1 =newStudent();
student.name ="james";
student.age =2;System.out.println(student.name);System.out.println(student.age);
student1.name ="curruy";
student1.age =1;System.out.println(student1.name);System.out.println(student1.age);}}
构造器底层原理
publicclassPet{publicString name;publicint age;//无参构造publicvoidshout(){System.out.println("哇哇哇哇");}}/*
* Pet dog = new Pet();
dog.name = "qqq";
dog.age = 1;
dog.shout();
System.out.println(dog.age);
System.out.println(dog.name);
Pet cat = new Pet();
* */
5.opp三大特性-封装
- 1.提高程序的安全性，保护数据
- 2.隐藏代码的实现细节
- 3.统一接口
- 4.系统可维护增加了
//类 private:私有publicclassStudent{privateString name;privateint id;privateint age;privatechar sex;//提供一些可以操作这个属性的方法！//提供一些publicd的get,set方法//alt +insert Fn//get 获得这个数据publicStringgetName(){return name;}//set 给这个数据设值publicvoidsetName(String name){this.name = name;}publicintgetId(){return id;}publicvoidsetId(int id){this.id = id;}publicchargetSex(){return sex;}publicvoidsetSex(char sex){this.sex = sex;}publicintgetAge(){return age;}publicvoidsetAge(int age){if(age>120||age<0){//不合法this.age =3;}else{this.age = age;}this.age = age;}}
测试：
Student s1 =newStudent();System.out.println("\t\t学生信息情况表");
s1.setName("秦严");System.out.println(s1.getName());
s1.setAge(18);System.out.println(s1.getAge());
s1.setSex('w');System.out.println(s1.getSex());
s1.setId(2020304621);System.out.println(s1.getId());
6.opp三大特性-继承
1.person、student、teacher
//person 人 基类：父类//java中所有的类默认直接或者间接继承ObjectpublicclassPerson{//extend ObjectprotectedString name ="Kg";publicPerson(){System.out.println("无参构造Person");}//只能用public,不能用private，私有的不能被继承publicvoidprint(){System.out.println("person");}}/*
* //继承用public 或者不加修饰符
int money = 1000_000;
public void say(){
System.out.println("哈哈哈哈哈哈哈哈哈");
}
//如果用private 可以构建一个get,set方法由子类来调用
private int money1 = 1444;
public int getMoney1() {
return money1;
}
public void setMoney1(int money1) {
this.money1 = money1;
}
* */
//学生 is person 派生类：子类//子类继承父类，就会拥有父类的全部方法publicclassStudentextendsPerson{//ctrl + H 展开继承树privateString name ="Qy";publicStudent(){//隐藏代码，调用了父类的无参构造super();//调用父类的构造器必须在子类构造器的第一行System.out.println("无参构造Student");}publicvoidprint(){System.out.println("student");}publicvoidtest1(){print();this.print();super.print();}publicvoidtest(String name){System.out.println(name);//方法参数中的System.out.println(this.name);//子类中的System.out.println(super.name);//父类 Person中的}}/*1.
* Student student = new Student();
student.say();
2.
* Student student = new Student();
System.out.println("===============1");
student.test("秦严");
System.out.println("===============2");
student.test1();
* */
//老师 is person 派生类：子类publicclassTeacherextendsPerson{}
2.A-B
publicclassAextendsB{//重写 @Override@Override//注解：由功能的注释publicvoidtest(){super.test();System.out.println("A=>test");}}/*
import com.oop.demo05.A;
import com.oop.demo05.B;
import com.oop.demo05.Student;
//静态方法：方法的调用只和左边，调用的数据有关
//非静态方法：重写
* public static void main(String[] args) {
A a = new A();
a.test();//A
//父类的引用指向子类
B b = new A();//子类继承父类，并重写了父类的方法
b.test();//B
}
* */
publicclassB{//重写都是方法的重写与属性无关publicvoidtest(){System.out.println("B=>test");}}
注意：
1. java中所有的类默认直接或者间接继承Object2.JAVA中类只有单继承，没有多继承! 一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子！3.Super-this（P，T，S）：
super注意点:
- super调用父类的构造方法，必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中!
- super和 this不能同时调用构造方法!
this注意点:
superVSthis:
1.代表的对象不同:
*** this: 本身调用者这个对象
*** super: 代表父类对象的应用
2.前提
*** this:没有继承也可以使用
*** super:只能在继承条件才可以使用
3.构造方法
*** this();本类的构造
*** super（）:父类的构造
方法重写（A，B）
子类继承父类，并重写了父类的方法
重写：需要有继承关系，子类重写父类
*** 1.方法名必须相同
*** 2.参数列表必须相同
*** 3.修饰符：范围可以扩大但不能缩小：public>protected>Default>private
*** 4.抛出的异常：范围可以缩小但不能扩大：classNotFoundException–>Exception(大)
重写，子类的方法和父类必须一致：方法体不同
为什么要重写：
***1. 父类的功能，子类不一定需要，或者不一定能满足！
***2.ALT+Insert(Fn):override
7.三大特性-多态
1.定义
2.instanceof（类型转换）引用类型
多态注意事项
- 1.多态是方法的多态，属性没有多态
- 2.子类父类，有联系，类型转换异常! ClassCastException!
- 3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son
- 4.以下不能重写：
1.static 方法 属于类 它不属于实例2.final 常量3.private 方法：
publicclassPerson{publicvoidrun(){System.out.println("run");}}/*
* 1. public void run(){
System.out.println("run!!!!!");
}
*
* */
publicclassStudentextendsPerson{publicvoidgo(){System.out.println("go");}}/*多态注意事项
* 1.多态是方法的多态，属性没有多态
* 2.子类父类，有联系，类型转换异常! ClassCastException!
* 3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son
* 4.以下不能重写：
* 1.static 方法 属于类 它不属于实例
* 2.final 常量
* 3.private 方法：
*
*1. @Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("吃");
}
*
*
* public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向引用类型就不确定了:父类的引用指向子类
// Student 能调用的方法都是自己的或者调用父类的
Student s1 = new Student();
// Person 父类型 指向子类，不可以调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
s2.run();
s1.run();//子类重写了父类的方法，执行子类的方法
//s2.eat（）;不能执行 对象能执行那些方法主要看左边类型，和右边关系不大
((Student)s2).eat();//可以强转后执行
}
*
*2.
* public static void main(String[] args) {
//Object>String
//Object>Person>Teacher
//Object>Person>Student
//System.out.println(X instanceof Y);//是否能编译通过取决于具有父子关系
//System.out.println(X instanceof Y);//true或者false取决于引用对象X指向的类型是不是Y的子类型
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//flase
System.out.println(object instanceof String);//flase
System.out.println("=======================");
Person person = new Student();
System.out.println( person instanceof Student);//true
System.out.println( person instanceof Person);//true
System.out.println( person instanceof Teacher);//false
System.out.println( person instanceof Object);//true
//System.out.println( person instanceof String);//编译报错
System.out.println("=======================");
Student student = new Student();
System.out.println( student instanceof Student);//true
System.out.println( student instanceof Person);//true
System.out.println( student instanceof Object);//true
// System.out.println( student instanceof Teacher);//编译报错
//System.out.println( person instanceof String);//编译报错
* */
publicclassTeacherextendsPerson{}/*
* public static void main(String[] args) {
//类型之间的转换 父 子（高转低 强制转换 低转高 自动转换）
//父类引用指向子类对象
//student将这个对象类型强制转换成Student类型，就可以使用Student类型的方法了
Person person = new Student();
((Student)person).go();
//子类转换为父类可能丢失一些自己本来的方法
Student student = new Student();
Person person1 = student;
}
*
* */
8.Static关键字、抽象类，接口
1.Static关键字
publicclassPerson{{System.out.println("匿名代码块");}static{System.out.println("静态代码块");}publicPerson(){System.out.println("构造方法");}publicstaticvoidmain(String[] args){Person person =newPerson();System.out.println("=============");Person person1 =newPerson();//静态代码块只执行一次}}
publicclassStudent{//静态属性privatestaticint age;//静态变量 多线程privateint score;//非静态变量//静态方法publicvoidrun(){}publicstaticvoidgo(){}publicstaticvoidmain(String[] args){Student s1 =newStudent();System.out.println(Student.age);//System.out.println(Student.score);类只能调用静态变量System.out.println(s1.score);System.out.println(s1.age);Student.go();go();//Student.run(); 不可以编译
s1.run();}}
//静态导入包importstaticjava.lang.Math.random;importstaticjava.lang.Math.PI;publicclassTest{publicstaticvoidmain(String[] args){System.out.println(random());System.out.println(PI);//类被final定义，无法继承}}
2.抽象类
- 抽象类的所有方法 继承他的子类 都必须实现的方法 除非也是抽象类public abstract class A extends
ActionpublicclassAextendsAction{@Overridepublicvoidsomething(){}}
// abstract 抽象类: extends 单继承 (接口可以多继承)插排publicabstractclassAction{//约束 不实现//abstract 抽象方法 只有方法名字，没有方法实现publicabstractvoidsomething();//1.不能new这个抽象类，只能靠子类实现它:约束//2.抽象类可以写普通方法，普通方法不能有抽象类}
3.接口
声明：interface
作用：
1.约束
2.定义一些方法，让不同的人实现
3.
public static final
public abstract
5.接口不能实例化，接口不能构造方法
6.inplements可以实现多个接口
7.必须重写接口中的方法
publicinterfaceTimeService{voidtime();}
// interface 是关键字，接口都需要有实现类publicinterfaceUserService{//常量 public abstract finalint age =99;//接口中的所有定义都是抽象的 public abstractpublicabstractvoidadd(String name);voiddelete(String name);voidupdate(String name);voidquery(String name);}
//抽象类extends//类 实现接口 implements 接口//实现接口中的类 就要重写接口中的方法//接口可以实现多继承publicclassUserServiceImpimplementsUserService,TimeService{@Overridepublicvoidadd(String name){}@Overridepublicvoiddelete(String name){}@Overridepublicvoidupdate(String name){}@Overridepublicvoidquery(String name){}@Overridepublicvoidtime(){}}
9.内部类
publicclassOuter{privateint id =11;publicvoidout(){System.out.println("外部类");}publicclass inner{publicvoidout(){System.out.println("内部类");}//获得外部类的私有属性publicvoidGetId(){System.out.println(id);}}}//一个java中只有一个public类，可以有多个class类class a{publicstaticvoidmain(String[] args){}}/*
* public static void main(String[] args) {
Outer outer = new Outer();
//通过外部类实例化内部类
Outer.inner inner = outer.new inner();
inner.GetId();
}
* */
publicclassOuter{privateint id =11;publicvoidout(){System.out.println("外部类");}publicclass inner{publicvoidout(){System.out.println("内部类");}//获得外部类的私有属性publicvoidGetId(){System.out.println(id);}}}//一个java中只有一个public类，可以有多个class类class a{publicstaticvoidmain(String[] args){}}/*
* public static void main(String[] args) {
Outer outer = new Outer();
//通过外部类实例化内部类
Outer.inner inner = outer.new inner();
inner.GetId();
}
* */
六、异常机制
1.异常定义
2.异常结构体
1.Error与Exception
Ctrl Alt T:自动生成抛出异常
3.异常处理机制与自定义异常
publicclassTest{publicstaticvoidmain(String[] args){int a =0;int b =1;try{//try监控区域if(a==0){//throw throwsthrownewArithmeticException();//主动抛出异常}System.out.println(b/a);}catch(ArithmeticException e){//catch 异常捕获
e.printStackTrace();System.out.println("程序出现异常，被除数不为0");}finally{//处理善后工作System.out.println("final");}//可以不要finall,在 假设 IO 资源 关闭//捕获多个异常 从小到大try{newTest().a1();}catch(RuntimeException e){System.out.println("出现异常1");}catch(Exception e){System.out.println("出现异常2");}catch(Throwable e){System.out.println("出现异常3");}}publicvoida1(){b1();}publicvoidb1(){a1();}}
publicclassTest1{publicstaticvoidmain(String[] args){newTest1().tset(10,0);}publicvoidtset(int a,int b){if(b==0){thrownewArithmeticException();//主动抛出异常，一般用在方法中}System.out.println(a/b);}}
实际应用中的经验总结：
本文转载自: https://blog.csdn.net/qq_46319647/article/details/135514721
版权归原作者 M.za 所有， 如有侵权，请联系我们删除。
版权归原作者 M.za 所有， 如有侵权，请联系我们删除。