面向对象查漏补缺3

抽象类

// 类前面加个abstract关键字就可以
// 抽象类不能new实例化

// 抽象类中可以没有抽象方法
// 抽象方法必须放在抽象类中

// 抽象类的子类必须实现父类的抽象方法
// abstract不能跟private,static,final搭配

接口

interface People {void say();}
interface Animal {void run();}
interface KKK extends People,Animal{}//接口可以多继承
class FFF implements People,Animal{}//实现多个

//接口匿名实现类的对象
People p = new People() {
    @Override
    public void say() {System.out.println("say....");}
};
People s = () -> System.out.println("say....");

抽象类更适合是一种模板，接口是一种能力

class Test{
    public static void main(String[] args) {
        Man m = new Man();
        People.kkk(); //接口中的static方法只能由接口来调
        //Man.kkk();
        //m.kkk(); // error,实现类不能调接口的static方法

        System.out.println(Man.a + m.a + People.a);// 接口中的属性都可以调

        // default方法可以被重写
        m.say(); // default方法只能由实现类对象来调用

        // 类实现了两个接口,两个接口中定义了同名同参数的default方法
        // 此时必须进行重写,不然报错

        // 父类和接口中定义了同名同参数的方法
        // 子类在调用时,使用的是父类中的
    }
}

class Man implements People{
    @Override
    public void say() {System.out.println("lll");}
    public void fff(){People.super.say();//在实现类中调用接口中的default方法}
}
interface People {
    int a = 2;
    //可以使用静态方法
    default void say(){kkk();System.out.println(a);}
    static void kkk(){
        //say();//error,static方法中不能使用non-static结构
        sss();
    }
    private static void sss(){}
}

内部类

// 在class的內部定义一个class
成员内部类:(static和非static的)可以使用四种权限修饰符
局部内部类:声明在(方法内,构造器内,代码块内)(匿名的和非匿名的)

class Test{
    public static void main(String[] args) {
        // 创建static成员内部类
        Man.Female female = new Man.Female();
        // 创建non-static成员内部类
        Man man = new Man(); // 要先创建外部类实例
        Man.Male male = man.new Male();
    }
}
class Man{
    String name;
    // non-static成员内部类
    class Male{
        String name;
        public void show(String name){
            System.out.println(name);// 指形参
            System.out.println(this.name);// 指内部类中的
            System.out.println(Man.this.name);// 指Man类中的
        }
    }
    static class Female{}//static成员内部类
    public Comparable ddd(){
        //局部内部类
        class MC implements Comparable{
            @Override
            public int compareTo(Object o) {return 0;}
        }
        return new MC();
    }
}

枚举

// 类的实例是确定个数的

class People{
    public static void main(String[] args) {
        // enum 继承了Enum类,所以有一些方法可以使用
        // 得到所有实例对象
        for (Season value : Season.values()) {value.show();}
    }
}
interface XC{void show();}
enum Season implements XC{
    // 类的对象是固定的,不能在外面创建对象
    // 必须在开头声明对象,用逗号隔开,类型都是 public static final Season,()代表创建对象时传的参数
    // public static final Season ppp = new Season("夏");

    SPRING("春"){//这时SPRING其实是Season的一个匿名子类的对象
        int a = 2;
        @Override
        public void show() {super.show();}
    },
    SUMMER("夏");
    String description;

    //构造器默认就是private
    Season(String description){this.description = description;}
    public void sss(){}//可以有自己的方法
    @Override//实现接口中的方法
    public void show() {System.out.println("重写" + description);}
}

包装类

// 8种基本数据类型都有其包装类,Character,Boolean
// Byte,Short,Integer,Long,Float,Double 他们的父类是Number
//(装箱)基本数据类型 ---> 包装类
int i1 = 10;Integer in1 = Integer.valueOf(i1);
float f1 = 12.3F;Float fl1 = Float.valueOf(f1);
//(拆箱)包装类 ---> 基本数据类型
int i = in1.intValue();
float v = fl1.floatValue();

Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);// false

//自动装箱,底层调用Interger.valueOf(int),查看valueOf源码
//Integer内部有一个IntegerCache类,创建Integer对象时,如果int的值在[-128,127],就返回IntegerCache提前创建好的对象
//当int的值不在这个范围时,则不相等,因为是两个不同的对象
Integer m1 = 128;Integer m2 = 128;
System.out.println(m1 == m2);// false
System.out.println(m1.equals(m2));//true

Integer n1 = 127;Integer n2 = 127;
System.out.println(n1 == n2);//true,同一个Integer对象

// int无法转换为Double,因为涉及到先升级再装箱,[拆装箱]一定要在[升降级]前面
// Integer无法转换为Double,因为要先拆箱再升级再装箱,涉及3步操作,不符合上述规律
//Double h = 1;//error
Double h = 1d;

boolean b = false;Integer num = null;
Integer result = b ? 0 : num;
//会报NullPointerException,null.intValue()
这是自动装箱/拆箱的特性,运算中有不同的类型,涉及到类型转换,编译器会往下(基本类型)转型,再进行运算.
运算中有int和Integer,Integer会先转成int再计算

https://blog.csdn.net/weixin_42463676/article/details/84866816