Java超详细基础知识
Java
Java基础
编写第一个Java程序
alt+/可以对代码进行补充。
package hello;
public class Hello {public static void main(String[] args){System.out.println("Hellow world");}
}1.在一个Java源文件中可以声明多个class。但是，只能最多有一个类声明为public的。而且要求声明为public的类的类名必须与源文件名相同。
2.程序的入口是main()方法。格式是固定的。
3.输出语句：System.out.println();先输出数据，然后换行
System.out.print();只输出数据
public class Hello{public static void main(String[] args){System.out.println("Hellow world");}
}
class Person{}
class Animal{}
eclipse调节字体
window—preference
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C2vlbsvk-1669854211619)(C:\Users\14182\AppData\Roaming\Typora\typora-user-images\image-20220621161111650.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R5YJj37g-1669854211621)(C:\Users\14182\AppData\Roaming\Typora\typora-user-images\image-20220621161024720.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2DE7fVGy-1669854211622)(C:\Users\14182\AppData\Roaming\Typora\typora-user-images\image-20220621161043534.png)]
Java注释
单行注释//，多行注释/* / ，文档注释/* */
1.单行注释和多行注释的作用：
- 对所写的程序进行解释说明，增强可读性，方便自己，方便比尔
- 调试缩写的代码
2.特点：单行注释和多行注释，注释了的内容不参与编译。
3.文档注释的使用：注释内容可以被jdk提供的工具javadoc所解析，生成一套生成一套以网页文件形式所体现的该程序的说明文档。
4.多行注释不可以嵌套使用
API文档
api是Java提供的基本编程接口。
jdk，jre，jvm三者之间的关系，以及jdk，jre包含的主要结构有哪些
jdk=jre+Java的开发工具（javac.exe,java.exe,javadoc.exe）
jre=jvm+java核心类库
为什么要配置path环境变量？
为了在任意目录下，使用javac/java命令
配置：JAVA_HOME = bin的上一层目录
path = %JAVA_HOME%\bin
关键字
**定义：**被Java语言赋予了特殊含义，用做专门用途的字符串。
**特点：**关键字中所有字母都为小写。
标识符
Java对各种变量，方法和类等要素命名时使用的字符序列叫标识符。
**技巧：**凡是自己可以起名字的地方都叫标识符。
定义合法标识符规则：
- 由26个英文字母大小写，0-9，_或$组成。
- 数字不可以开头。
- 不可以使用关键字和保留字，但能包含关键字和保留字。
- Java中严格区分大小写，长度无限制。
- 标识符不能包含空格。
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名，接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
- 变量名，方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写
- 常量名：所有字母都大写，多个单词时每个单词用下划线连接。
变量
**概念：**内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元。包含变量类型，变量名和存储的值
**作用：**用于在内存中保存数据
Java定义变量的格式：数据类型 变量名 = 变量值；
数据类型：基本数据类型：数值型，字符型(char)，布尔型（boolean)
数值型：整数类型(byte1字节,short2字节,int4字节,long8字节)，浮点类型(float,double)
引用数据类型：类(class)，接口(interface)，数组([]array)
class VariableTest1{public static void main(String[] args){//1.整型：byte(1字节=8bit) \ short(2字节) \ int(4字节)\ long(8字节)//byte范围-128~127byte b1 = 12;byte b1 = -128;//b2 = 128;//编译不通过System.out.println(b1);System.out.println(b2);// 2.声明long型变量，必须以“l”或“L”结尾//通常，定义整型变量时，使用int型。short s1 = 128;int i1 = 1234;long l1 = 3414234324L;System.out.println(l1);//2.浮点型：float(4字节) \ double(8字节)//1.浮点型，表示带小数点的数值//float表示数值的范围比long还大double d1 = 123.3;System.out.println(d1 + 1);//3.定义float类型变量时，变量要以“f”或“F”结尾。float f1= 12.3F;System.out.println(f1);//4.通常，定义浮点型变量时，使用double型。//5.字符型：char(1字符=2字符)//定义char型变量，通常使用一对'',内部只能有一个字符char c1= 'a';//编译不通过//c1 = 'AB';char c2= '1';char c3= '中';System.out.println(c1);System.out.println(c2);System.out.println(c3);//表示方式：1.声明一个字符 2.转义字符 3.直接使用Unicode值来表示字符常量char c5 = '\n'; //换行符c5 = '\t';//制表符System.out.print("hello" + c5);System.out.println("world");char c6 = '\u0043';System.out.println(c6);//4.布尔型：boolean//只能取两个值之一：true，false//常常在条件判断，循环结构中使用boolean bb1=true;System.out.println(bb1);boolean isMarried =true;if(isMarried){System.out.println("你就不能参加单身party了！"); }else{System.out.println("你可以多谈谈女朋友!");}}
}
强制类型转换
1.自动类型提升：
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升到容量大的数据类型。
byte，char，short — int — long — float — double
特别的：当byte，char，short三种类型的变量做运算时，结果为int型。
2.强制类型转换：自动类型提升无法运算时，用强制转换
说明：此时的容量大小指的是，表示数的范围的大和小。
class VariableTest2{public static void main(String[] args){byte b1 = 2;int i1 = 129;//编译不通过，因为byte范围比int小//byte b2 = b1 + i1；int i2 = b1 + i1;long l1 = b1 + i1;System.out.println(i2);float f = b1+i1;System.out.println(f);}
}
class VariableTest3{public static void main(String[] args){double d1 = 12.9;int i1 = (int)d1;//截断操作，因为double范围比int类型大，d1无法自动提升到int，所以需要强行转换成int类型System.out.println(i1);}
}
class VariableTest4{public static void main(String[] args){//1.编码情况：long l= 123213;System.out.println(l);//123213后面美加l确可以运行，是因为把它当作了int类型，而且他没有超过int类型的范围。//编译失败：过大的整数//long l1= 2156431215;}
}
String类型变量的使用
1.String属于引用数据类型，翻译为：字符串
2.声明String类型变量时，使用一对" "
3.String可以和8种基本数据类型变量做运算，且运算只能是连接运算"+"
class StringTest {public static void main(String[] args){String s1 = "Hello world!";System.out.println(s1);string s2 = "a";string s3 = "";//string里面可以有一个字符，可以没有字符//char C=''; char里面必须有字符，空格也算int number = 1001;String numberStr = "学号：";String info = numberStr + number;//+ 前后只要有一个String类型的变量就是连接运算，如果都没有则是加法运算。System.out.println(info);//从左到右进行运算，只要遇到一个string类型，后面就全是string类型了。 char c = 'a';//97int num = 10;String str = "hello";System.out.println(c + num + str);//107helloSystem.out.println(c + str + num);//ahello10System.out.println(c + (num + str));//a10helloSystem.out.println((c + num) + str);//107helloSystem.out.println(str + num + c);//hello10a}
}
运算符
算术运算符：+ — * / %
class AriTest{public static void main(String[] args){int num1 = 12;int num2 = 5;int result1 = num1 / num2; //int类型进行运算，所以结果是2，而不是2.4System.out.println(result1); //2int result2 = num1 / num2 * num2;//从左到右进行运算System.out.println(result2); //10 double result3 = num1 / num2;//因为右边先进性整型运算成为了2，然后在左边赋值小数，所以为2.0System.out.println(result3);//2.0 double result4 = num1 / num2 + 0.0;//2.0double result5 = num1 / (num2 + 0.0);//2.4double result6 = (double)num1 / num2;//2.4double result7 = (double)(num1 / num2);//2.0System.out.println(result5);//%取余运算//结果的符号与被模数的符号相关int m1 = 12;int n1 = 5;System.out.println("m1 % n1 = " + m1 % n1)//2int m1 = -12;int n1 = 5;System.out.println("m2 % n2 = " + m1 % n1)//-2int m1 = 12;int n1 = -5;System.out.println("m3 % n3 = " + m1 % n1)//2int m1 = -12;int n1 = -5;System.out.println("m4 % n4 = " + m1 % n1)//-2//(前)++：先自增1，后在运算 //(后)++：先运算，后自增1//自增1不会改变变量本身的数据类型int a1 = 10;int b1 = ++a1;System.out.println("a1 = " + a1 +",b1 = " + b1);//a1=11,b1=11int a2 = 10;int b2 = a2++;System.out.println("a2 = " + a2 +",b2 = " + b2);//a2=11,b2=10int a3 = 10;++a3; //a3++; 这两个在这里运算时没有区别，最后都是11int b3 = a3;//(前)——:先自减1，后运算//(后)——:先运算，后自减1int a4 = 10;int b4 = a4——;//int b4 = ——a4;System.out.println("a4= " + a4 + ",b4 = " + b4)}
}
输出187百位十位个位
class AriExer {public static void main(String[] args){int num = 187;int bai = num / 100;int shi = num % 100 / 10;int ge = num % 10;System.out.println("百位为：" + bai);System.out.println("十位为：" + shi);System.out.println("个位为：" + ge);}}
”=“赋值运算
class SetValueTest {public static void main(String[] args){//赋值符号：=int i1 = 10;int j1 = 10;int i2,j2;//连续赋值i2 = j2 = 10;int i3 = 10,j3 = 20;int num1 = 10;num1 += 2;//+=就是 num1 = num1 + 2;System.out.println(num1);//12int num2 = 12;num2 %= 5;//num2 = num2 % 5;System.out.println(num2);short s1 = 10;//s1 = s1 + 2;//编译失败s1 += 2;//不会改变变量本身的数据类型System.out.println(s1);}
}
//练习1
int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1练习2
int m = 2;
int n = 3;
n *= m++;//n = n * m++;
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6
练习3
int n = 10;
n += (n++) + (++n);//n = n + (n++) + (++n); 从左到右进行运算，n是10，n++先运算为10后加1为11，++n先加1，所以为12
System.out.println(n);//32
比较运算符
== != > < >= <= instanceof
比较运算符的结果是Boolean类型
class CompareTest {public static void main(String[] args){int i = 10;int j = 20;System.out.println(i == j);//falseSystem.out.println(i = j);//20boolean b1 = true;boolean b2 = false;System.out.println(b2 == b1);//falseSystem.out.println(b2 = b1);//true}}
逻辑运算符
&逻辑与 &&短路与 | 逻辑或 ||短路或 ^逻辑异或 ！逻辑非
class LogicTest {public static void main(String[] args){//区分& 和 &&//相同点1：&与&&的运算结果相同//相同点2：当符号左边是true时，二者都会执行符号右边的运算//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不在执行符号右边的运算。boolean b1 = true;int num1 = 10;if(b1 & (num1++ > 0)){System.out.println("我现在在北京"); }else{System.out.println("我现在在南京"); }System.out.println("num1 = " + num1);boolean b2 = true;int num2 = 10;if(b2 && (num2++ > 0)){ //如果b2是false，则(num2++ >0)则不执行System.out.println("我现在在北京");}else{System.out.println("我现在在南京");}System.out.println("num2 = " + num2);//区分：| 与 ||//相同点1：| 与 || 的运算结果相同//相同点2：当符号左边是false时，二者都会执行符号右边的运算//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不在执行符号右边的运算boolean b3 = false;int num3 = 10;if(b3 | (num3++ > 0)){System.out.println("我现在在北京");}else{System.out.println("我现在在南京");}System.out.println("num3 =" + num3);boolean b4 = false;int num4 = 10;if(b4 | (num4++ > 0)){System.out.println("我现在在北京");}else{System.out.println("我现在在南京");}System.out.println("num4 =" + num4);}}
位运算符：
1.位运算符操作的都是整型的数据
2.<<:在一定范围内，每向左移1位，相当于*2 左移几位，空位补几位0
3.>>:在一定范围内，每向右移1位，相当于 / 2 右移最高位是0补0，最高位是1补1，因为正数补正数，负数补负数。
class BitTest{public static void main(String[] args){int i = 21;i = -21;System.out.println("i << 2:" + (i << 2));System.out.println("i << 3:" + (i << 3));System.out.println("i << 27:" + (i << 27));//练习：交换两个变量的值int num1 = 10;int num2 = 20;System.out.println("num1 = " + num1 + ",num2 =" + num2);//方式一：定义临时变量的方式//int temp = num1;//num1 = num2;//num2 = temp;//方式二：好处：不用定义临时变量//弊端：1相加操作可能超出存储范围2有局限性：只能适用于数值类型 num1 = num1 + num2;num2 = num1 - num2;num1 = num1 - num2;System.out.println("num1 = " + num1 + ",num2 =" + num2);}
}
三元运算符
1.结构：(条件表达式)？表达式1：表达式2
2.说明：条件表达式的结果为Boolean类型
根据条件表达式真或假，决定执行表达式1，还是表达式2
如果表达式为true，则执行表达式1.
如果表达式为false，则执行表达式2.
3.表达式1和表达式2的类型要一致
4.凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。
5.如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选用三元运算符。原因：简单，整洁
class SanYuanTest{public static void main(String[] args){//获取两个正数的较大值int m = 12;int n = 5;int max = (m > n)? m : n;System.out.println(max);//获取三个数的最大值int n1 = 12;int n2 = 30;int n3 = -43;int max1 = (n1 > n2)?n1 : n2;int max2 = (max1 > n3)?max1 : n3;System.out.println("三个数中的最大值为：" + max2);if(m > n){System.out.println(m);}else{System.out.println(n);}}
}分支结构if-else(条件判断结构)
1.三种结构：
第一种：
if(条件表达式){
执行表达式
}
第二种：二选一
if(条件表达式){
执行表达式1
}else{
执行表达式2
}
第三种：多选一
if(条件表达式){
执行表达式1
}else if(条件表达式){
执行表达式2
}else if(条件表达式){
执行表达式3
}
…
else{
}
class IfTest {//举例1public static void main(String[] args){int heartBeats = 179;if(heartBeats < 60 || heartBeats > 100){System.out.println("需要进一步检查")}System.out.println("检查结束");}//举例2int age = 23;if(age < 18){System.out.println("你还可以看动画片");}else{System.out.println("你可以看成人电影");}//举例3if(age < 0){System.out.println("您输入的数据非法");}else if(age < 18){System.out.println("青少年时期");}else if(age < 35){System.out.println("青壮年时期");}else if(age < 60){System.out.println("中年时期");}else if(age < 120){System.out.println("老年时期");}else {System.out.println("你要成仙啊");}}
如何从键盘获取不同类型的变量，需要使用Scanner类
具体步骤：
1.导包：import Java.util.Scanner;
2.Scanner的实例化：Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法，来获取指定类型的变量
注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不相符时，会报异常inputmismathexce导致程序终止。
import java.util.Scanner;
class ScannerTest{public static void main(String[] args){Scanner scan = new Scanner(System.in);int num = scan.nextInt();System.out.println(num);System.out.println("请输入你的姓名：");String name = scan.next();System.out.println(name);System.out.println("请输入你的芳龄：");int age = scan.nextInt();System.out.println(age);System.out.println("请输入你的体重：");double weight = scan.nextDouble();System.out.println(weight);System.out.println("你是否相中我了呢？(true/false)");boolean isLove = scan.nextBoolean();System.out.println(isLove);//对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串。System.out.println("请输入你的性别：(男/女)");String gender = scan.next();char genderChar = gender.charAt(0);//获取索引为0位置上的字符System.out.println(genderChar);}}
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆bmw；
成为为（80,99]时，奖励一台iPhone xs max；
当成为为[ 60,80]时，奖励一个ipad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断。
import java.util.Scanner;
class IfTest {public static void main(String[] args){Scanner scan = new Scanner(System.in);System.out.println("请输入岳小鹏期末成绩：0-100");int score = scan.nextInt();if(score == 100){System.out.println("奖励一辆bmw");}else if(score >80 && score <= 99){System.out.println("奖励一台iPhone xs max");}else if(score >= 60 && score<= 80){System.out.println("奖励一个ipad");}else{System.out.println("什么奖励也没有");}}}
编写程序：由键盘输入三个整数分别存入变量num1，num2，num3，对他们进行排序，使用(if - else)，并且从小到大输出。
import java.util.Scanner;
class IfTest2 {public static void main(String[] args){Scanner scanner = new Scanner(System.in);System.out.println("请输入第一个整数：");int num1 = scanner.nextInt();System.out.println("请输入第二个整数：");int num2 = scanner.nextInt();System.out.println("请输入第三个整数：");int num3 = scanner.nextInt();if(num1 >= num2){if(num3 >= num1){System.out.println(num2 + "," + num1 + "," + num3);}else if{System.out.println(num3 + "," + num2 + "," + num1);}else{System.out.println(num2 + "," + num3 + "," + num1);}}else{if(num3 >= num2){System.out.println(num1 + "," + num2 + "," + num3);}else if(num3 <= num1){System.out.println(num3 + "," + num1 + "," + num2);}else{System.out.println(num1 + "," + num3 + "," + num2);}}}}
分支结构switch-case
1.格式
switch(表达式){
case 常量1：
执行语句1；
//break
case 常量2；
执行语句2;
//break
…
default;
执行语句n;
//break;
}
2.说明：
根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
break，可以使用在switch–case结构中，表示一旦执行到此关键字，就跳出switch-case。
switch结构中的表达式，只能是如下的6种数据类型之一：
byte，short，char，int，枚举类型，string类型
class SwithCaseTest{public static void main(String[] args){int number = 2;switch(number){case 0:System.out.println("zero");case 1:System.out.println("one");case 2:System.out.println("two"); case 3:System.out.println("three");default:System.out.println("other");}}
}
循环结构
class circle {public static void mian(String[] args){for(int i = 1;i<= 5000;i++){System.out.println("Hello World!");}int num = 1;for(System.out.print('a');num <= 3; System.out.print('c'),num++){System.out.print('b'); }}
}
请输入两个正整数m和n，求其最大公约数和最小公倍数。
比如12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用
import java.util.Scanner;
class ForTest{public static void main(String[] args){Scanner scan = new Scanner(System.in);System.out.prinln("请输入第一个正整数：");int m = scan.nextInt();System.out.println("请输入第二个正整数：");int n = scan.nextInt();//获取最大公约数//获取两个数中的较小值int min = (m <= n)? m:n;for(int i = min;i >= 1 ;i--){if(m % i == 0 && n % i == 0){System.out.println("最大公约数为："+i);break;}}//获取最小公倍数//1.获取两个数中的较大值int max = (m >= n)? m:n;for(int i = max;i <= m * n;i++){if(i % m == 0 && i% n ==0){System.out.println("最小公倍数："+i);break;}}}
}
while循环结构
①
while(②){
③;
④;
}
说明：写while循环千万小心不要丢了④迭代条件，一旦丢了可能导致死循环。
写程序要避免死循环。
for循环和while循环是可以相互转换的！
for循环和while循环的初始化条件部分的作用范围不同。
算法：有限性。
class WhileTest{public static void main(String[] args){//遍历100以内的所有偶数int i = 1;while(i <= 100){if(i % 2 ==0 ){System.out.println(i);}i++;}//出了while循环以后，仍可以调用。System.out.println(i);}
}
do-while循环结构。
一，循环结构的4个要素
①初始化条件
②循环条件 ----是Boolean类型
③循环体
④迭代条件
二，do-while循环结构:
①
do{
③;
④;
}while(②);
执行过程：1-3-4-2-3-4-…-2
说明：1.do-while循环至少会执行一次循环体！
class DoWhileTest {public static void main(String[] args){//遍历100以内的偶数,并计算所有偶数的和及偶数的个数。int num = 1;int sum = 0;//记录总和int count = 0;//记录个数do{if(num % 2 == 0){System.out.println(num);sum += num;++count;}num++;}while(num <= 100);System.out.println("总和为：" + sum);System.out.println("个数为：" + count);int number1 = 15;while(number1 > 10){System.out.println("hello:while");number1--;}int number2 = 15;do{System.out.println("hello:do-while");number2--;}while(number2 > 10);}
}
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环。
class ForForTest {public static void main(String[] args){for(int j=1;j<= 4;j++){for(int i = 1;i<=6;i++){System.out.print('*');}System.out.println();}}
}
九九乘法表
class NineNineTabel{public static void main(String[] args){for(int i=1;i<=9;i++){for(int j = 1;j<=i;j++){System.out.print(i + "*" + j + " = " + (i * j) + " ")}System.out.println();}}
}
break和continue关键字的使用
使用范围：1.break：switch-case，循环结构
2.continue：循环结构
循环结构中使用的作用：1.break：结束当前循环
2.continue：结束当此循环
class BreakContinnueTest{public static void main(String[] args){for(int i=1;i<=10;i++){if(i % 4 == 0){break;//123}System.out.print(i);}}
}
class BreakContinnueTest{public static void main(String[] args){for(int i=1;i<=10;i++){if(i % 4 == 0){continue;//123567910}System.out.print(i);}}
}
第一个程序
class FamilyAccount{public static void main(String[] args){boolean isFlag = true;//用于记录用户的收入和支出的详情String details = "";while(isFlag){System.out.println("--------家庭收支记账软件---------");System.out.println("1.收支明细");System.out.println("2.登记收入");System.out.println("3.登记支出");System.out.println("4.退出");System.out.println("请选择(1-4):");char selection = utility.readMenuSelection();switch(selection){case '1':System.out.println("------当前收支明细记录------");System.out.println("收支\t账户金额\t收支金额\t说明\n");System.out.println("details");System.out.println("-------------------------");break;case '2':System.out.println("本次收入金额：");int money = Utility.readNumber();System.out.println("本次收入说明：");String info = Utility.readString();//处理balancebalance += money;//处理detailsdetails += ("收入\t" + balance + "\t" + money + "\t" + info);System.out.println("-------本次登记完成------");break;case '3':System.out.println("本次支出金额：");int money = Utility.readNumber();System.out.print("本次支出说明：");String info = Utility.readString();if(balance >= money){balance -= money;details += ("收入\t" + balance + "\t" + money + "\t" + info);}else{System.out.println("支出超出账户额度，支付失败");}System.out.println("------本次登记完成--------");break;case '4':System.out.println("确认是否退出(Y/N):");char isExit = Utility.readConfirmSelection();if(isExit == 'Y'){isFlag = false;}}}}
}
数组
1.数组(array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的形式对这些数据进行统一管理。
2.数据相关的概念：
数组名，元素，角标，下标，索引，数组的长度：元素的个数。
3.数组的特点：
①数组是有序排列的
②数组属于引用数据类型的变量。数组的元素既可以是基本数据类型，也可以是引用数据类型。
③创建数组对象会在内存中开辟一整块连续的空间
④数组的长度一旦确定，就不能修改。
4.数组的分类：
①按照维数：一维数组，二维数组，。。
②按照数组元素的类型：基本数据类型元素的数组，引用数据类型元素的数组。
5.一维数组的使用：
①一维数组的声明和初始化
②如何调用数组的指定位置的元素
③如何获取数组的长度
④如何遍历数组
⑤数组元素的默认初始化值
⑥数组的内存解析
public class ArrayTest {public static void main(String[] args){//1.一维数组的声明和初始化int num;//声明num = 10;//初始化int id = 1001;//声明+初始化int[] ids;//声明//1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行。ids = new int[]{1001,1002,1003,1004};//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行。String[] names = new String[5];//2.如何调用数组的指定位置的元素：通过角标的方式调用。//数组的角标(或索引)从0开始的，到数组的长度-1结束。names[0] = "王铭";names[1] = "王赫";names[2] = "张学良";names[3] = "孙居龙";names[4] = "王宏志";names[5] = "周扬";//3.如何获取数组的长度。//属性：lengthSystem.out.println(names.length);System.out.println(ids.length);//4.如何遍历数组System.out.println(name[0]);System.out.println(name[1]);System.out.println(name[2]);System.out.println(name[3]);System.out.println(name[4]);for(int i = 0;i < names.length;i++ ){System.out.println(names[i]);//数组元素的默认初始化值1.数组元素是整型：02.数组元素是浮点型：0.03.数组元素是char型：0或'\u0000',而非'0'4.数组元素是boolean型：false5.数组元素是引用数据类型：nullint[] arr = new int[4];for(int i =0;i< arr.length;i++){System.out.println("******");}short[] arr1 = new short[4];for(int i = 0;i < arr1.length;i++){System.out.println(arr1[i]);float[] arr1 = new short[4];for(int i = 0;i < arr2.length;i++){System.out.println(arr1[i]);char[] arr1 = new short[4];for(int i = 0;i < arr3.length;i++){System.out.println(arr1[i]);}if(arr3[0] == 0){System.out.println("你好！");}System.out.println("*********");boolean[] arr4 = new boolean[5];System.out.println(arr4[0]);System.out.println("******");String[] arr5 = new String[5];System.out.println(arr5[0]);if(arr5[0] == null){System.out.println("北京天气不错！");}}}
}
二维数组：
1.对于二维数组的理解，可以看成一维数组array1又作为另一个一维数组array2元素的存在。其实，从数组底层的运行机制来看，其实没有多维数组。
2.二维数组的使用：
①二维数组的声明和初始化
②如何调用数组的指定位置的元素
③如何获取数组的长度
④如何遍历数组
public class ArrayTest2{public static void main(String[] args){//1.二维数组的声明和初始化int[] arr = new int[]{1,2,3};//静态初始化int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};//动态初始化String[][] arr2 = new String[3][2];//动态初始化String[][] arr3 = new String[3][];//也是正确的写法int[] arr4[] = new int[][]{{1,2,3},{4,5},{6,7,8}};int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//2.如何调用数组的指定位置的元素System.out.println(arr1[0][1]);//2System.out.println(arr2[1][1]);//nullarr3[1] = new String[4];System.out.println(arr3[1][0]);//3.获取数组的长度System.out.println(arr4.length);//3System.out.println(arr4[0].length);//3System.out.println(arr4[1].length);//2//4.如何遍历二维数组for(int i = 0;i < arr4.length;i++){for(int j = 0;j< arr4[i].length;j++){System.out.print(arr4[i][j] + "");}System.out.println();}}
}
二维数组分为外层数组的元素，内层数组的元素
int[] [] arr = new int[4] [3];
外层元素：arr[0],arr[1]等
内层元素：arr[0] [0],arr [1] [ 2]等
⑤数组元素的默认初始化值
针对于初始化方式一：比如：int[] [] arr = new int [4] [3];
外层元素的初始化值为:地址值
内层元素的初始化值为:与一维数组初始化情况相同
针对于初始化方式二：比如：int[] [] arr = new int [4] [];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。
⑥数组的内存解析
public class ArrayTest3{public static void main(String[] args){int[][] arr = new int[4][3];System.out.println(arr[0]);system.out.println(arr[0][0]);float[][] arr1 = new float[4][3];System.out.println(arr1[0]);system.out.println(arr1[0][0]);String[][] arr2 = new String[4][3];System.out.println(arr2[0]);system.out.println(arr2[0][0]);}double[][] arr3 = new double[4][];System.out.println(arr3[1]);//null,没有赋值就为空了system.out.println(arr3[1][0]);//没有赋值，在继续往下找，就会报错}}
}
定义一个int型的一维数组，包含10个元素，分别附一些随机的整数，然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。要求：所有随机数都是两位数。
public class ArrayTest1{public static void main(String[] args){int[] arr = new int[10];for(int i = 0;i< arr.length;i++){arr[i] = (int)(Math.random() * (99-10+1)+10);}//求数组元素的最大值int maxValue = arr[0];for(int i = 1;i < arr.length;i++){if(maxValue < arr[i]){maxValue = arr[i];}System.out.println("最大值为："+maxValue);}//求数组元素的最小值int minValue = arr[0];for(int i = 1;i < arr.length;i++){if(minValue < arr[i]){minValue = arr[i];}System.out.println("最小值为："+minValue);}//求数组元素的总和int sum = 0;for(int i = 0;i<arr.length;i++){sum += arr[i];}System.out.println("总和为："+sum);//求数组元素的平均数int avgValue = sum / arr.length;System.out.println("平均数为："+avgValue);}
}
二分法查找
前提：所要查找的数组必须有序。
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333}int dest1 = -34;int head = 0;int end = arr2.length - 1;
boolean isFlag1 = true;
while(head <= end){int middle = (head + end)/2;if(dest1 == arr2[middle]){System.out.println("找到了指定的元素，位置为："+middle);isFlag1 = false;break;
}else if(arr2[middle] > dest1){end = middle - 1;
}else{head = middle + 1;}if(isFlag1){System.out.println("很遗憾，没有找到的啦！");}
}冒泡排序法
public class BubbleSortTest{public static void main(String[] args){int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};for(int i = 0;i < arr.length;i++){for(int j = 0;j < arr.length;i++){if(arr[j] > arr[j + 1]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}
}
面向对象
1.面向过程：强调的是功能行为，以函数为最小单位，强调怎么做。
①把冰箱门打开
②抬起大象，塞进冰箱
③把冰箱门关闭
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
人{
打开(冰箱){
冰箱.开开();
}
抬起(大象){
大象.进入(冰箱);
}
关闭(冰箱){
冰箱.闭合();
}
}
冰箱{
开开(){}
闭合(){}
}
大象{
进入(冰箱){
}
}
一，类和对象是面向对象的核心概念。
类：是对一类事物的描述，是抽象的，概念上的定义。
对象：是实际存在的该类事物的每个个体，因而也称为实例.
二，类和对象的使用(面向对象思想落地的实现)
1.创建类，设计类的成员
2.创建类的对象
3.通过“对象.属性”或“对象.方法”调用对象的结构
三，如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性(非static的)，意味着：如果我们修改一个对象的属性a，则不影响另外一个属性a的值。
public class PersonTest{public static void main(String[] args){//创建Person类的对象Person p1 = new Person(); //调用对象的结构：属性，方法//调用属性：“对象.属性”p1.name = "Tome";p1.isMake = true;System.out.println(p1.name);//调用方法：“对象.方法”p1.eat();p1.sleep();p1.talk("Chinese");Person p2 = new Person();System.out.println(p2.name);System.out.println(p2.isMale);Person p3 = p1;System.out.println(p3.name);p3,age = 10;System.out.println(p1.age);}
}
class Person{//属性String name;int age = 1;boolean isMale;//方法public void eat(){System.out.println("人可以吃饭");}public void sleep(){System.out.println("人可以睡觉");}public void talk(String language){System.out.println("人可以说话，使用的是：" + language);}
}
类中属性的使用
属性(成员变量) vs 局部变量
1.相同点：
1.1定义变量的格式：数据类型 变量名 = 变量值
1.2先声明，后使用
1.3变量都有其对应的作用域
2.不同点：
2.1在类中声明的位置的不同
属性：直接定义在类的一对{};
局部变量：声明在方法内，方法形参，代码块内，构造器形参，构造器内部的变量。
2.2关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符
常用的权限修饰符：private,public,缺省,protected
局部变量：不可以使用权限修饰符
2.3默认初始化值的情况
属性：类的属性，根据其类型，都有默认初始化值
整型(byte,short,int,long):0
浮点型(float,double,):0.0
字符型(char):0(‘\u0000’)
布尔型(boolean)
引用数据类型(类，数组，接口):null
局部变量：没有默认初始化值。
意味着，我们在调用局部变量之前，一定要显示赋值。
特别的：形参在调用时，我们赋值即可。
2.4在内存中加载的位置
属性：加载到堆空间中(非static)
局部变量：加载到栈空间
3.返回值类型：有返回值 和 没有返回值
3.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，如果使用return关键字来返回指定类型的变量或常量。
如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return。但是，如果使用的话，只能“return；”表示结束此方法的意思。
3.2形参列表：方法可以声明0个，1个，或多个参数。
3.2.1格式：数据类型1 形参1，数据类型2 形参2，…
4.return关键字的使用：
4.1使用范围：使用在方法体中
4.2作用：①结束方法
②针对于有返回值类型的方法，使用“return 数据”方法返回所要的数据。
4.3注意点：return关键字后面不可以声明执行语句。
5.方法的使用中，可以调用当前类的属性或方法
特殊的：方法a中又调用了方法a：递归方法
方法中，不可以定义方法。
public class UserTest{public static void main(String[] args){User u1 = new User();System.out.println(u1.name);System.out.println(u1.age);System.out.println(u1.isMale);u1.talk("日语");
}
}
class User{//属性(或成员变量)private String name;public int age;boolean isMale;public void talk(String language){//language:形参，也是局部变量System.out.println("我们使用" + language + "进行交流");}public void eat(){String food = "烙饼";//局部变量System.out.println("北方人喜欢吃" + food);}}
面向对象思想编程内容的三条主线分别是什么
1.类及类的成员：属性，方法，构造器：代码块，内部类
2.面向对象的三大特征：封装，继承，多态
3.其它关键字：this，super，abstract等等
public class UserTest{public static void main(String[] args){User u1 = new User();System.out.println(u1.name);System.out.println(u1.age);System.out.println(u1.isMale);u1.talk("日语");//匿名对象new Phone().eat();
}
}
class User{//属性(或成员变量)private String name;public int age;boolean isMale;public void talk(String language){//language:形参，也是局部变量System.out.println("我们使用" + language + "进行交流");}public void eat(){String food = "烙饼";//局部变量System.out.println("北方人喜欢吃" + food);}}
方法的重载(overload)
1.定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。调用时，是什么类型就调用什么类型的方法。
2.举例：Arrays类中重载的sort() / binarySearch()、
3.判断是否是重载：跟方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系。
因为在调用时，判断是否是同一个的话，只能根据什么类型来判断(int,string等类型)
4.在通过对象调用方法时，如何确定某一指定的方法
方法名—参数列表
public class OverLoadTest{public static void main(String[] args){OverLoadTest test = new OverLoadTest();test.getSum(1,2);
}public void getSum(int i,int j){System.out.println("1");}public void getSum(double i,double j){System.out.println("1");}public void getSum(String i,int j){System.out.println("1");}public void getSum(double i,int j){System.out.println("1");}
}
可变个数参数的格式：数据类型…变量名
1.当调用可变个数形参的方法时，传入的参数个数是：0个，1个，2个…
2.可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
3.可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载，换句话说，二者不能共存。
4.可变个数形参在方法的形参中，必须声明在末尾。
5.可变个数形参在方法的形参中，最多只能声明一个可变形参。
public class MethodArgsTest{public static void main(String[] args){MethodArgsTest test = new MethodArgsTest();test.show(12);test.show("hello");test.show("hello","world");test.show("AA","BB","CC");}public void show(int i){}public void show(String s){System.out.println("show(String)");}public void show(String ...strs){System.out.println("show(String....strs)");for(int i = 0;i < strs.length;i++){System.out.println(strs[i]); }}
}
递归方法的使用
1.递归方法：一个方法体内调用它自身。
2.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制，递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
public class RecursionTest{public static void main(String[] args){//例1.计算1-100之间所有自然数的和//方法一int sum = 0;for(int i = 1;i <= 100;i++){sum += i;}//方法二RecursionTest test = new RecursionTest();int sum1 = test.getSum(100);System.out.println(sum1);}//方法二public int getSum(int n){if(n == 1){return 1;}else{return n + getSum(n - 1);}}
}
值传递
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
public class ValueTransferTest{public static void mian(String[] args){System.out.println("*****基本数据类型：****");int m = 10;int n = m;System.out.println("m = " + m + ",n = " + n);n = 20;System.out.println("m = " + m + ",n = " + n);System.out.println("*****引用数据类型：****");Order o1 = new Order();o1.orderId = 1001;Order o2 = o1;System.out.println("o1.OrderId = " + O1.OrderId + ",O2.OrderId = "+O2.OrderId);O2.orderId = 1002;System.out.println("o1.OrderId = " + O1.OrderId + ",O2.OrderId = "+O2.OrderId);}}
方法的形参的传递机制：值传递
1.形参：方法定义时，声明的小括号内的参数
2.实参：方法调用时，实际传递给形参的数据
public class ValueTransferTest1{public static void main(String[] args){int m = 10;int n = 20;System.out.println("m = " + m + ", n = "+ n);//交换两个变量的值的操作int temp = m ;m = n;n = temp;System.out.println("m = " + m + ", n = "+ n);swap(arr,j,j + 1);}//错误的：交换数组种指定两个位置元素的值public void swap(int i,int j){int temp = i;i = j;j = temp;}//正确的：交换数组种指定两个元素的值public void swap(int[] arr//(引用类型),int i,in j){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;
}
}
封装
为什么需要封装？
我们要用洗衣机，只需要按一下开关和洗涤模式就可以了，有必要了解洗衣机内部的结构吗？有必要碰到电动机吗？
封装的含义：封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。被封装的对象通常被称为抽象数据类型。
封装的作用：封装的作用在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。
我们的程序设计追求”高内聚，低耦合“。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉。
低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性，可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
问题的引入，当我们创建一个类的对象以后，我们可以通过”对象.属性“的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值，加入额外的限制条件，这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。(比如：setlegs)，同时，我们需要避免用户再使用”对象.属性“的方式对属性进行赋值。则需要将属性声明为私有。
此时针对属性，就是体现了封装性。
二，封装性的体现：
我们将类的属性xxx私有化(private)，同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值。
三，封装性的体现，需要权限修饰符来配合。
1.Java规定的4种权限(从小到大排列)：private，缺省，protected，public
2.4种权限可以用来修饰类及类的内部结构：属性，方法，构造器，内部类
3.具体的，4种权限都可以用来修饰类的内部结构：属性，方法，构造器，内部类
修饰类的话，只能使用：缺省，public
总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
public class AnimalTest{public static void main(String[] args){Animal a = new Animal();a.name = "大黄";a.age = 1;a.legs = 4;a.setLegs(6);a.show();}
}
class Animal{String name;int age;int legs;public void setLegs(int l){if(l >= 0 && l % 2 == 0){legs = 1;}else{legs = 0;}}public void eat(){System.out.println("动物进食");}public void show(){System.out.println("name = " + name + ",age = " + age + ",legs = " +legs);}//提供关于属性age的get和set方法public int getAge(){return age;}public void setAge(int a){age = a;}
}
构造器(构造方法，constructor)的使用
一，构造器的作用：
创建对象
初始化对象的属性
二，说明：
1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。
2.定义构造器的格式：权限修饰符 类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载。
4.一旦我们现实的定义了类的构造器之后，系统就不再提供默认的空参构造器。
5.一个类中，至少会有一个构造器。
public class PersonTest{public static void main(String[] args){//创建类的对象：new + 构造器Person p = new Person();p.eat();Person p1 = new Person("Tom");System.out.println(p1.name);}
}
class person{String name;int age;//构造器public Person(){System.out.println("Person().....");}public Person(String n){name = n;}public void eat(){System.out.println("人吃饭");}public void study(){System.out.println("人可以学习");}
}
this关键字的使用
作用：为了区分同名，当形参和变量同名时，引入this关键字可以区分
1.this可以用来修饰：属性，方法，构造器
2.this修饰属性和方法：
this理解为：当前对象或当前正在创建的对象
在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略”this.“。特殊情况下，如果方法的形参和类的属性同名时，我们必须现实使用”this.变量“的方式，表明此变量是属性，而非形参。
3.this调用构造器
①我们在类的构造器中，可以显式的使用“this(形参列表)”方式，调用本类中指定的其他构造器
②构造器中不能通过“this(形参列表)”方式调用自己
③如果一个类中有n个构造器，则最多有n—1构造器中使用了“this(形参列表)”
④规定：“this（形参列表）‘必须声明在当前构造器的首行
⑤构造器内部，最多只能声明一个”this(形参列表)“，用来调用其他的构造器
public class PersonTest{public static void main(String[] args){Person p1 = new Person();p1.setAge(1);System.out.println(p1.getAge());}
}
class Person{private String name;private int age;public Person(){}public Person(String name){name = name}public void setName(String name){this.name = name;}public String getName(){return name;}public void setAge(int age){this.age = age;}public int getAge(){return age;}
}
一，package关键字的使用
1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包，声明在源文件的首行
3.包，属于标识符，遵循标识符的命名规则，规范(xxxyyyzzz),”见名知意“
4.每”.“一次，就代表一层文件目录。
补充：同一个包下，不能命名同名的接口，类
不同包下，可以命名同名的接口，类
import关键字的使用
import：导入
1.在源文件中显式的使用import结构导入指定包下的类，接口
2.声明在包的声明和类的声明之间
3.如果需要导入多个结构，则并列写出即可
4.可以使用”xxx.*“的方式，表示可以导入xxx包下的所有结构
5.如果使用的类或接口是Java.lang包下定义的，则可以省略import结构
6.如果使用的类或接口是本包下定义的，则可以省略import结构
7.如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
8.使用”xxx.*“方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则容需要显示导入。
继承性
一，继承性的好处：
①减少了代码的冗余，提高了代码的复用性
②便于功能的扩展
③为之后多态性的使用，提供了前提
二，继承性的格式：class A extends B{}
A : 子类，派生类，subclass
B : 父类，超类，基类，superclass
体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的属性和方法。
特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。
子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。子类和父类的关系，不同于子集和集合的关系。
三，Java中关于继承性的规定：
1.一个类可以被多个子类继承。
2.Java中类的单继承性：一个类只能有一个父类。
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类。
5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。
四，1.如果我们没有显式的声明一个类的父类的话，则此类继承于Java.lang.Object类
2.所有的Java类(除Java.lang.Object类之外)都直接或间接的继承于Java.lang.Object类
3.意味着，所有的Java类具有Java.lang.Object类声明的功能。
class Person {private String name;private int age;public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}public String getName() {return this.name;}public int getAge() {return this.age;}
}class Student extends Person {}public class Demo04 {public static void main(String[] args) {Student stu = new Student();stu.setName("张三");stu.setAge(23);System.out.println("学生姓名:" + stu.getName() + "，年龄：" + stu.getAge() + "岁。");}
}
例二//子类实例化对象之前会自动先实例化父类对象，调用了父类无参构造方法
class A{public A() {System.out.println("A、A类的构造方法");}
}class B extends A{public B() {System.out.println("B、B类的构造方法");}
}public class Demo04 {public static void main(String[] args) {new B();}
}
例三//如果父类没有无参构造，就必须使用super（）明确调用父类有参构造方法
class A{public A(String title) {System.out.println("A、A类的构造方法");}
}class B extends A{public B(String title) {super(title);System.out.println("B、B类的构造方法");}
}public class Demo04 {public static void main(String[] args) {new B("Hello"); }
}
重写(override / overwrite)
1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。
2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
3.重写的规定：
方法的声明：权限修饰符 返回值类型 方法名(形参列表){
//方法体
}
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
①子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
②子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符。
特殊情况:子类不能重写父类中声明为private权限的方法
③返回值类型：
父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须是double)。
④子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
子类和父类中的同名同参数的方法要么都声明为非static的(考虑重写),要么都声明为static的(不是重写)。
public class Person{String name;int age;public Person(){}public Person(String name,int age){this.name = name;this.age = age;
}public void eat(){System.out.println("吃饭");}public void walk(int distance){System.out.println("走路,走的距离是："+distance+"公里");}
}
public class Student extends Person{String major;public Student(){}public Student(String major){this.major = major;}public void study(){System.out.println("学习的专业是："+ major);
}
}
public class PersonTest{public static void main(String[] args){Student s = new Student("计算机科学与技术");s.eat();s.walk(10);s.study();}
}
super关键字
1.super理解为：父类的
2.super可以用来调用：属性，方法，构造器
3.super的使用
3.1我们可以在子类的方法或构造器中。通过使用“super.属性”或“super.方法”的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略“super.”
3.2特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用“super.属性”的方式，表明调用的是父类中声明的属性。
3.3特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用“super.方法”的方式，表明调用的是父类中被重写的方法。
4.super调用构造器
4.1我们可以在子类的构造器中显式的使用“super(形参列表)”的方式，调用父类中声明的指定的构造器
4.2“super(形参列表)”的使用，必须声明在子类构造器的首行！
4.3我们在类的构造器中，针对于“this(形参列表)”或“super(形参列表)”只能二选一，不能同时出现
4.4在构造器的首行，没有显式的声明“this(形参列表)”或“super(形参列表)”，则默认调用的是父类中空参的构造器：super()
4.5在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表)”，调用父类中的构造器
子类对象实例化的全过程
1.从结果上来看：(继承性)
子类继承父类以后，就获取了父类中声明的属性或方法。
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
2.从过程上来看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，直到调用了Java.lang.Objec类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。
明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。
public class SuperTest{public static void main(String[] args){Student s = new Student();s.show();s.eat();s.study()Student s1 = new Student("Tom",21,"IT");s1.show();System.out.println("************");Student s2 = new Student();}
}
public class Person{String name;int age;int id;public Person(){System.out.println("我无处不在I");}public Person(String name){this.name = name;}public Person(String name,int age){this(name);this.age = age;}public void eat(){System.out.println("人：吃饭");}public void walk(){System.out.println("人：走路");}}
public class Student extends Person{String major;int id = 1002;public Student(){}public Student(String major){super();this.major = major;}public Student(String name,int age,String major){this.name = name;this.age = age;super(name,age);this.major = major;}@Overridepublic void eat(){System.out.println("学生：多吃有营养的食物");}public void study(){System.out.println("学生：学习知识");this.eat();super.eat();super.walk();}public void show(){System.out.println("name = " + this.name +",age = " + super.age);System.out.println("id = " + this.id);System.out.println("id = " + super.id);}
}
多态
1.理解多态性：可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象(或子类的对象赋给父类的引用)
3.多态的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写的方法。
总结：编译，看左边。运行，看右边。
4.多态性的使用前提：①类的继承关系②方法的重写
5.对象的多态性，只适用于方法，不适用于属性(编译和运行都看左边)
public class Person{String name;int age;int id = 1001;public void eat(){System.out.println("人：吃饭");}public void walk(){System.out.println("人：走路");}
}
public class Man extends Person{boolean isSmoking;int id = 1002;public void earnMoney(){System.out.println("男人负责赚钱养家");}public void eat(){System.out.println("男人多吃肉，长肌肉");}public void walk(){System.out.println("人：走路");}
}
public class Woman extends Person{boolean isBeauty;public void goShopping(){System.out.println("女人喜欢购物");}public void eat(){System.out.println("女人少吃，为了减肥");}public void walk(){System.out.println("人：走路");}
}
public class PersonTest{public static void main(String[] args){Person p1 = new Person();p1.eat();Man man = new Man();man.eat();man.age = 25;man.earnMoney();System.out.println("*********");//对象的多态性：父类的引用指向子类的对象Person p2 = new Man();//多态的使用：当调用子父类同名同参数的方法时，实际执行的时子类重写父类的方法---虚拟方法调用p2.eat();p2.walk();System.out.println(p2.id);Man m1 = (Man)p2;m1.earnMoney();m1.isSmoking = true;Woman w1 = (Woman)p2;w1.goShopping();/*instanceof关键字的使用a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。使用情境：为了避免在向下转型时出现ClassCastExpection的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，则a instanceof B也返回true。其中，类B是类A的父类。*/if(p2 instanceof Woman){Woman w1 = (Woman)p2;w1.goShopping();System.out.println("****Woman****");}if(p2 instanceof Woman){Woman w1 = (Woman)p2;w1.goShopping();System.out.println("****Woman****");}if(p2 instanceof Man){Man m2 = (Man)p2;m2.earnMoney();System.out.println("****Man****");}if(p2 instanceof Person){System.out.println("****Person****");}if(p2 instanceof Object){System.out.println("****Object****");}//问题一：编译时通过，运行时不通过Person P3 = new Woman();Man m3 = (Man)p3;//问题二：编译通过，运行时也通过Object obj = new Woman();Person p = (Person)obj;//问题三：编译不通过Man m5 = new Woman();String str = new Date();}
}
多态性举例一
public class AnimalTest{public static void main(String[] args){AnimalTest test = new AnimalTest();test.func(new Dog());test.func(new Cat());}public void func(Animal animal){animal.eat();animal.shout();}public void func(Dog dog){dog.eat();dog.shout();}public void func(Cat cat){cat.eat();cat.shout();
}
}
class Animal{public void eat(){System.out.println("动物：进食");}public void shout(){System.out.println("动物：叫");}
}
class Dog extends Animal{public void eat(){System.out.println("狗吃骨头");}public void shout(){System.out.println("汪汪汪");}} class Cat extends Animal{public void eat(){System.out.println("猫吃鱼");}public void shout(){System.out.println("喵喵喵");}}
Class Order{public void method(Object obj){}
}
class Driver{public void doData(Connection conn){}
}
}
Object类
java.lang.Object类
1.Object类是所有Java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能(属性，方法)就具有通用性。
4.Object类只声明了一个空参构造器
public class ObjectTest{public static void main(String[] args){Order order = new Order();System.out.println(order.getClass().getSuperclass());}
}
class Order{}
==和equals()的区别
一，回顾 == 的使用：
== ： 运算符
1.可以使用在基本数据类型变量和引用数据类型变量中
2.如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。
如果比较的是引用数据类型变量：比较两个对象的地址值是否相同,即两个引用是否指向同一个对象实体。
二，equals()方法的使用：
1.是一个方法，而非运算符
2.只能适用于引用数据类型
3.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的“实体内容”是否相同。那么，我们就需要对Object类中的equals()进行重写。
public class EqualsTest{public static void main(String[] args){int i = 10;int j = 10;double d = 10.0;System.out.println(i == j);System.out.println(i == d);boolean b = true;char c = 10;System.out.println(i == c);char c1 = 'A';char c2 = 65;Sysetem.out.println(c1 == c2);Customer cust1 = new Customer("Tom",21);Customer cust2 = new Customer("Tom",21);Sysetem.out.println(cust1 == cust2);//falseString str1 = new String("atu");String str2 = new String("atu");Sysetem.out.println(str1 == str2);//falseSystem.out.println(cust1.equals(cust2));System.out.println(str1.equals(str2));}
}
public class Customer{private String name;privcate int age;//一堆get，set方法
}
接口
接口用关键字interface修饰
public interface 接口名{}
类实现接口用implements表示
public class 类型 implements 接口名{}
接口不能实例化
接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫做接口。
多态的形式：具体类多态，抽象类多态，接口多态。
多态的前提：有继承或者实现关系，有方法重写，有父(类/接口)引用指向(子/实现)类对象
接口的成员特点
成员变量：
只能是常量
默认修饰符：public static final
构造方法：
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在的
一个类如果没有父类，默认继承自Object类
成员方法：
只能是抽象方法
默认修饰符：public abstract
public class InterfaceDemo{public static void main(String[] args){Inter i = new InterImpl();System.out.println(i.num);System.out.println(i.num2);}
}
public class InterImpl implements Inter{public InterImpl(){super();}
}
接口名作为形参和返回值
方法的形参是接口名，其实需要的是该接口的实现类对象
方法的返回值是接口名，其实返回的是该接口的实现类对象
public interface Jumpping{void jump();
}
public class JumppingOperator{public void useJumpping(Jumpping j){j.jump();}
}
public class JumppingDemo{public static void main(String[] args){//创建操作类对象，并调用方法JumppingOperator jo = new JumppingOperator();}
}
父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能(属性，方法)就具有通用性。
4.Object类只声明了一个空参构造器
public class ObjectTest{public static void main(String[] args){Order order = new Order();System.out.println(order.getClass().getSuperclass());}
}
class Order{}
==和equals()的区别
一，回顾 == 的使用：
== ： 运算符
1.可以使用在基本数据类型变量和引用数据类型变量中
2.如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。
如果比较的是引用数据类型变量：比较两个对象的地址值是否相同,即两个引用是否指向同一个对象实体。
二，equals()方法的使用：
1.是一个方法，而非运算符
2.只能适用于引用数据类型
3.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的“实体内容”是否相同。那么，我们就需要对Object类中的equals()进行重写。
public class EqualsTest{public static void main(String[] args){int i = 10;int j = 10;double d = 10.0;System.out.println(i == j);System.out.println(i == d);boolean b = true;char c = 10;System.out.println(i == c);char c1 = 'A';char c2 = 65;Sysetem.out.println(c1 == c2);Customer cust1 = new Customer("Tom",21);Customer cust2 = new Customer("Tom",21);Sysetem.out.println(cust1 == cust2);//falseString str1 = new String("atu");String str2 = new String("atu");Sysetem.out.println(str1 == str2);//falseSystem.out.println(cust1.equals(cust2));System.out.println(str1.equals(str2));}
}
public class Customer{private String name;privcate int age;//一堆get，set方法
}
接口
接口用关键字interface修饰
public interface 接口名{}
类实现接口用implements表示
public class 类型 implements 接口名{}
接口不能实例化
接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫做接口。
多态的形式：具体类多态，抽象类多态，接口多态。
多态的前提：有继承或者实现关系，有方法重写，有父(类/接口)引用指向(子/实现)类对象
接口的成员特点
成员变量：
只能是常量
默认修饰符：public static final
构造方法：
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在的
一个类如果没有父类，默认继承自Object类
成员方法：
只能是抽象方法
默认修饰符：public abstract
public class InterfaceDemo{public static void main(String[] args){Inter i = new InterImpl();System.out.println(i.num);System.out.println(i.num2);}
}
public class InterImpl implements Inter{public InterImpl(){super();}
}
接口名作为形参和返回值
方法的形参是接口名，其实需要的是该接口的实现类对象
方法的返回值是接口名，其实返回的是该接口的实现类对象
public interface Jumpping{void jump();
}
public class JumppingOperator{public void useJumpping(Jumpping j){j.jump();}
}
public class JumppingDemo{public static void main(String[] args){//创建操作类对象，并调用方法JumppingOperator jo = new JumppingOperator();}
}
Java超详细基础知识相关推荐
- HTML超详细基础知识总结
文章目录 前言 一.互联网基本原理 1.在本地开发,在服务器共享 2.关于 HTTP 协议 3.前后端请求交互基本流程 二.HTML基础语法以及延伸 1.HTML解析 1.1.什么是HTML 1.2. ...
- linux shell输出数字小数点前少了0_南京课工场IT培训：SHELL 超详细基础知识,适合新手小白（一）
一.什么是shell? 在linux内核与用户直接的解释器程序: 通常指/bin/bash; 相当于操作系统的"外壳". 二.怎么使用shell? shell的使用方式? 1. 命 ...
- python详细基础知识笔记
详细基础知识笔记 注: ·第一章 学习准备 1.1高级语言.机器语言.汇编语言 1.2 汇编.解释 1.3 静态语言.脚本语言 1.4 Python的历史 1.5 Python语言的优点.缺点 1.6 ...
- java 网络爬虫 正则表达式_【干货】Java网络爬虫基础知识
原标题:[干货]Java网络爬虫基础知识 引言 Java 网络爬虫具有很好的扩展性可伸缩性,其是目前搜索引擎开发的重要组成部分.例如,著名的网络爬虫工具 Nutch 便是采用 Java 开发,该工具以 ...
- 【超全】Go语言超详细学习知识体系
Go语言超详细学习知识体系 Go编程入门 基础语法 环境安装 下载地址 https://golang.google.cn/dl/ GOPATH.GOROOT两个关键环境变量 基础结构 包的概念 程序执 ...
- java的一些基础知识（引用BlogJava 落花飞雪）
java的一些基础知识(引用BlogJava 落花飞雪) <Practical Java>笔记 1. 声明是什么? String s = "Hello world!" ...
- Python超详细基础教程,从入门到实践
Python超详细基础入门 一.变量和简单数据类型 (一)修改字符串大小写 (二)制表符和换行符 (三)删除空白 (四)数 二.列表 (一)列表定义 (二)修改.添加和删除元素 (三)组织列表 三.操 ...
- 【Java】【基础知识】【Java的基本使用】
[Java][基础知识][Java的基本使用] 基于jdk8 仅个人理解,或有疏漏 基于 java疯狂讲义 第三版和第四版 java核心技术卷一 第十版和第十一版 廖雪峰java课程 一.基本数据与结 ...
- Java 网络编程基础知识
Java 网络编程基础知识 基础概念 计算机网络的基本概念 网络:多台计算机使用网络设备互联在一起,计算机之间可以进行通信,这样就组成了一个计算机网络. 网络设备:集线器(HUB),路由器,交 ...
最新文章
- 1008c语言答案,c语言大作业题目01008.doc
- ReflectionToStringBuilder
- dropout与lstm的结合使用
- mac homebrew
- Python下使用optparse模块实现对多个文件进行统计【二】
- C++对象模型3--无重写的单继承
- python横向输出字符串_Python字符串拼接和格式化输出
- 《猎豹行动》出版一周年了！
- 站长统计工具区别：百度统计、51la统计系统和cnzz数据统计工具
- 相对路径遍历Relative Path Traversal
- CF687 D2 C. Bouncing Ball(DP)
- 一个故事带你看透HTTPS（上）
- 有n个结构体变量，内含学生学号、姓名和3门课程的成绩。要求输出平均成绩最高的学生的信息(包括学号、姓名、3门课程成绩和平均成绩)。
- php 爬取新闻,scrapy抓取学院新闻报告
- 企业级应用Service Management Automation X（SMAX）的微服务之路
- spicy（一）基本定义
- word自动设置表格格式
- 微信小程序开发实录——每日速递
- matlab潮流计算求节点自导纳,matlab潮流计算.docx
- 求500以内的10个最大素数及其和，并分别输出这10个最大素数及其和。