抽象类
// 类前面加个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