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 ;

​ (1)跳出当前循环 ,执行当前循环下边的语句 (此时忽略循环体中的任何其他语句)

​ ( 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 ;

​ (1)终止本次循环 , 跳过当前这次循环中continue语句后尚未执行的语句,紧接下次循环条件的判断。

​  (2)跳出当前循环的本轮操作并进入下一轮操作

​ (3)结束 label 所标记的循环: continue label ;

​ (4)终止当前的循环过程,但并不跳出循环 , 而是继续往下判断循环条件执行语句

​ (5)只能结束循环中的一次过程 , 但不能终止循环继续进行

// 一个简单的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 ;

​ (1)在方法中可以通过return终结当前方法,并返回给调用者

​ (2)return 返回一个值给调用该方法的语句,返回值的数据类型必须与方法的声明中的返回值的类型一致

​ (3)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、 吐槽

​ 今天考试的时候那个次大数没理解,其他的都太粗心了,典型的马大哈!

标签

© 2021 成都云创动力科技有限公司 蜀ICP备20006351号-1