DESKTOP-QT2JO23_20200829-孙中霞
1、抽象类 PK 接口
1.1抽象类与接口的不同
| 抽象类 | 接口 | |
|---|---|---|
| 构造 | 有构造(供子类构造调用) | 没有构造 |
| 初始化器 | 可以有初始化器 ( 类初始化器 和 实例初始化器 ) | 不能有 |
| 具体方法 | 可以有非抽象方法 (从Object类继承的方法都是非抽象的) |
JDK 1.8 开始，这个可以有 ( static 修饰或 default 修饰) |
| 抽象方法 | 可以有抽象方法，也可以没有抽象方法 可使用除了private以外的任意权限修饰符 |
可以有抽象方法，也可以没有抽象方法 只能是 public 修饰的 |
| 常量(Field) | 可以有 | 只能有常量 |
| 普通字段 | 可以有 可以是各种权限修饰符 |
不能有 ( 因所有字段默认都是 public static final 修饰的) |
| 继承 | 一个子类只能继承一个父类 | 一个接口可以继承多个父接口 |
| 实现 | 一个类可以实现多个接口 | 接口只能继承接口，不能实现接口 |
抽象类 可以包含 native 方法，而 接口 不允许包含 native 方法
1.2抽象类与接口的相同点
都不能被实例化
- 抽象类有构造但不允许实例化，构造供子类构造调用
- 接口没有构造，因此绝对不可能被实例化
- 无论是抽象类还是接口都是 abstract 修饰符修饰的
修饰方法时:
abstract不能跟static连用abstract不能跟final连用
2 、抽象类 PK 具体类
2.1 相同点
1>它们都是类，都有字段，有方法，有构造方法，且都可被继承
2.2 不同点
2.2.1 实例化
1>抽象类是不能被实例化的，就是不能用new调出构造方法创建对象;
2>非抽象类可以被实例化
2.2.2 访问权限
1> 抽象类的访问权限
public / protected
注:因为抽象类的方法是需要继承之后让子类去实现的，如果为Private，则无法被子类继承，子类也无法实现该方法
2>具体类的访问权限
public / protected / package-private / private
2.2.3 继承
1>抽象类的继承
抽象类可以继承抽象类,也可继承具体类
2>具体类的继承
具体类可以继承其他类,但要是继承抽象类,必须全部实现抽象父类中所有的抽象方法
2.2.4 方法
1>具体类的方法
可以有其他方法,但是不可以有抽象方法,但可被任意修饰符修饰
2>抽象类的方法
抽象方法只能在抽象类中,不可是 private 和 final 修饰的
2.2.5 修饰符
1>抽象类是由abstract修饰的
2>具体类是非abstract修饰的
3、super PK this
3.1相同点
3.1.1 this 和 super 都是与实例有关的
1>使用 this 和 super 可以访问 实例成员 和 类成员
虽然通过 this 和 super 有方位 类成员 ，但不建议使用
因此 this 和 super 都不能出现在 类方法中 和 类初始化器
3.1.2 this 和 super 都可以用于调用构造方法
1>当通过 this( [arguments] ) 或 super( [arguments] ) 调用构造方法时，它们必须位于构造方法的第一行
2>同一个构造方法内部 this( [arguments] ) 或 super( [arguments] ) 不能同时出现
3.2不同点
3.2.1 所表示实例不同
this 代表本类的当前实例，即可以通过this访问本类中的成员 ( this 可以单独使用 )
super 用于访问从父类中继承的、可见的成员 (super不能表示父类实例，不能单独使用)
3.2.2 调用的构造方法不同
this 用于调用本类内部的其它重载的构造方法
super 用于调用父类中的构造方法
3.2.3 访问的成员不同
通过 this. 可以访问本类中以及从父类中继承的、可见的 成员 ( 方法 和 属性(字段) )
通过 super. 可以访问从父类中继承的、可见的成员 ( 方法、字段(属性) )
3.2.4使用方式不同
this 关键字可以单独使用，比如 直接输出 this 或当作返回值
this 关键字在本类中可以省略 ( 比如 getName 方法 中，return this.name; 可以写作 return name ; )
super 关键字不可以单独使用，必须通过 super( [arguments] ) 或 super. 形式来使用
4、Override PK Overload
### 4.1 相同点
4.1.1 地点不同
override 发生在父类与子类之间,且它们直接是继承关系
overload 发生在同一个类中，是一个类中多态性的表现
4.1.2 规则不同
override 的参数列表（参数类型，参数个数，类型顺序），返回类型（除去子类方法的返回类型是父类返回类型的子类）必须相同
overload 的参数列表(参数类型,参数个数,类型顺序)不同,且返回值类型可相同可不相同
4.1.3 访问权限
override 中访问修饰符不能小于父类被重写的方法(public > protected > package-private >private)
overload 中的方法的访问修饰符号可以是任意访问修饰符
4.1.4 表现不同
override 是父类与子类之间多态性的表现,在运行时起作用(运行时类型)
overload是一个类中多态性的表现,在编译时起作用(编译时类型)
4.2 共同点
唯一的共同点就是它们的方法名要相同
5、＂＝＝＂运算符 PK ＂equals＂方法
5.1 共同点
都是用于两者之间的比较
5.2 不同点
5.2.1＂＝＝＂ 运算符
（1）基本数据类型比较值:只要两个变量的值相等，即为true
（2）引用类型比较引用：
1>指向同一个对象,结果返回true(即两个引用变量指向同一个对象的堆空间)
2>指向不同的对象,即使对象内容相同,结果返回false
注意：当基本数据类型使用“==”进行比较时，符号两边的数据必须类型兼容（类型相同或可自动类型转换），否则编译出错；
5.2.2 equals( )方法
(1)equals ( )方法中,所有的类都继承了Object
(2)自定义类可以重写equals( )方法
(3)类String 及包装类来说 , JDK已经重写过 equals ( )方法比较的是两个对象的类型及内容
(4)String 已经重写了Object 的equals ( ) , 则其判断两个字串是否相等的规则 : 就是判断两个字符串的内容是否相等
*** 注 *** 如果一个类型没有重写过equals( )方法,则 "equals" 等价 "=="
6、" break " , " continue " , " return " 的区别
6.1 跳出循环--- b r e a k ;
（１）跳出当前循环 ，执行当前循环下边的语句 (此时忽略循环体中的任何其他语句)
( 2 )只能跳出一层循环 , 在嵌套循环中 , 要[逐步判断 , 逐步跳出]
( 3 )break 再循环体内 , 强制结束整个循环过程 , 不再判断循环条件
( 4 )当 break 出现在循环体中的 switch 语句体中 , 只是跳出该 switch 语句体
*** 注解 * **就近原则 , 结束当前整个循环
（5）跳出label标记循环：break label;
label:for() {
// 两层for循环，再循环语句结束的时候，
//外层循环退出：break outer;
//内层循环退出：break inner;(默认为break;)
｝
//其label可以是 outer / inner
// 外层循环
outer: for (int j = 0; j < 5; j++) {
// 内层循环
for (int k = 0; k < 3; k++) {
System.out.println(j + " "+ k);
if (k == 1) {
// 跳出outer标签所标识的循环
break outer;
}
}
}
//结果为 0 0
0 1
6.2 跳转--- c o n t i n u e ;
（１）终止本次循环 , 跳过当前这次循环中continue语句后尚未执行的语句，紧接下次循环条件的判断。
（２）跳出当前循环的本轮操作并进入下一轮操作
（３）结束 label 所标记的循环: continue label ;
（４）终止当前的循环过程，但并不跳出循环 , 而是继续往下判断循环条件执行语句
（５）只能结束循环中的一次过程 , 但不能终止循环继续进行
// 一个简单的for循环
for (int i = 0; i < 3; i++) {
System.out.println("i" +" "+ i);//0 , 1 , 2
if (i == 1) {
// 忽略本次循环剩余的语句
continue;
}
System.out.println(i);//0 , 2
}
//结果为 i 0
0
i 1
i 2
2
6.3 返回--- r e t u r n ;
（１）在方法中可以通过return终结当前方法，并返回给调用者
（２）return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致
（３）return后面可不带参数(默认返回空)，其主要目的是想中断函数执行，返回给调用者
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
System.out.println("i的值是"+i);//1,2,3
if (i == 2) {
return;
}
System.out.println(i);//0,1
}
}
注 : final
(1)final修饰符
(2)final不能修饰构造方法
(3) final修饰类，该类不允许被继承
(4)操作系统不会对 final修饰的成员变量(包括类变量和实例变量) 隐式的初始化
(5)final修饰的局部变量在定义时可以不指定初始值，在之后的代码中赋值且只能赋值一次
(6)final修饰基本类型变量不能对基本类型变量重新赋值，final修饰引用类型变量，final只保证引用变量引用的地址不会改变
(7)final修饰的成员变量必须显示的指定初始值（只能在 实例初始化器 或 声明该实例变量 或 构造器 中指定初始值），
(8)final修饰类变量，(必须且只能在) 类初始化器 中指定 初始值 或 声明该变量时指定初始值
不管是类变量还是实例变量还是局部变量，当满足条件：
使用final修饰符 , 在定义该变量时指定了初始值 , 该初始值在编译时就被确定下来 , 则该变量相当于一个直接量
7、次大数（冒泡求解）
public class SecondMax {
public static void main(String[] args) {
int[] data = { 19, 22, 98, 00, 56, 77, 45, 72, 0, -1 };
for (int i = 0; i < data.length - 1; i++) {
for (int j = 0; j < data.length - 1 - i; j++) {
if (data[j] < data[j + 1]) {
int temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
System.out.println(java.util.Arrays.toString(data));
System.out.println("data数组的次大数为" + data[1]);
}
}
8、孪生素数
8.1 一
public class TwinPrime {
public boolean prime(int n) {
for(int i=2; i<n;i++) {
if(n%i==0) {
return false;
}
}
return true;
}
public static void main(String[] args) {
TwinPrime t=new TwinPrime();
for(int j=3;j<100;j++) {
if(t.prime(j)) {
if(t.prime(j+2)) {
int s=j+2;
System.out.println(j+" "+s);
}
}
}
}
}
8.2 二
public class TwinPrime2 {
public static void main(String[] args) {
int a[] = new int[1000];
int flag, n = 0;
for (int i = 2; i < 1000; i++) {
flag = 1;
for (int j=2; j < i; j++) {
if (i % j == 0) {
flag = 0;
break;
}
}
if (flag == 1) {
a[n] = i;
n++;
}
}
System.out.println("1000以内孪生素数为：");
for (int i = 0; i < n - 1; i++) {
if (a[i + 1] - a[i] == 2) {
System.out.println(" " + a[i + 1] + "," + a[i]);
}
}
}
}
9、 吐槽
今天考试的时候那个次大数没理解，其他的都太粗心了，典型的马大哈！
