Java基础语法08-面向对象-枚举-包装类-接口

枚举

枚举是一种特殊的类它的对象是有限固定的几个常量对象。

JDK1.5之前

• 构造器加private私有化

• 本类内部创建一组常量对象，并添加public static修饰符，对外暴露这些常量对象

JDK1.5之后格式

【修饰符】 enum 枚举类名{
　　常量对象列表;
　　其他成员列表;
}

枚举类的要求和特点：

• 枚举类的常量对象列表必须在枚举类的首行，因为是常量，所以建议大写。

• 如果常量对象列表后面没有其他代码，那么“；”可以省略，否则不可以省略“；”。

• 编译器给枚举类默认提供的是private的无参构造，如果枚举类需要的是无参构造，就不需要声明，写常量对象列表时也不用加参数，

• 如果枚举类需要的是有参构造，需要手动定义private的有参构造，调用有参构造的方法就是在常量对象名后面加(实参列表)就可以。

• 枚举类默认继承的是java.lang.Enum类，因此不能再继承其他的类型。

• JDK1.5之后switch，提供支持枚举类型，case后面可以写枚举常量名。

• 枚举类型如有其它属性，建议（不是必须）这些属性也声明为final的，因为常量对象在逻辑意义上应该不可变。

常用方法：

1.toString(): 默认返回的是常量名（对象名），可以继续手动重写该方法！
2.name():返回的是常量名（对象名） 【很少使用】
3.ordinal():返回常量的次序号，默认从0开始
4.values():返回该枚举类的所有的常量对象，返回类型是当前枚举的数组类型，是一个静态方法
5.valueOf(String name)：根据枚举常量对象名称获取枚举对象

Enum类只有一个唯一的构造器

protected Enum(String name, int ordinal)

包装类

序号	基本数据类型	包装类（java.lang包）
1	byte	Byte
2	short	Short
3	int	Integer
4	long	Long
5	float	Float
6	double	Double
7	char	Character
8	boolean	Boolean
9	void	Void

1、装箱与拆箱

装箱：把基本数据类型-->包装类对象

手动装箱：例如：new Integer(int值) 或 Integer.valueOf(int值)

自动装箱：Integer i = int值;

拆箱：把包装类的对象-->基本数据类型

手动拆箱：例如：Integer的对象.intValue()

自动拆箱：int i = Integer的对象;

注意：只能与自己对应的类型之间才能实现自动装箱与拆箱。

包装类的一些API

包装类有缓存对象

Byte	-128~127
Short	-128~127
Integer	-128~127
Long	-128~127
Float	没有
Double	没有
Character	0~127
Boolean	true和false

没有缓存对象的类或超出缓存的类，每一个都是新new的

包装类对象不可变：一旦修改就是新对象。如：方法的参数传递，不会改变原先的对象的值

接口

使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

Interface的方所有法访问权限自动被声明为public。确切的说只能为public

可以用abstract修饰符修饰，修饰之后就有了类的属性（如在同一.java文件中不能再声明一个public 权限的类了，其他待验证）

【修饰符】 interface 接口名{
　　// 静态常量
　　// 抽象方法
　　// 默认方法
　　// 静态方法
　　// 私有方法
}

1、公共的静态的常量：public static final

2、公共的抽象的方法：public abstract

非抽象的实现类必须重写

3、公共的默认方法：public default，JDK1.8之后

使用“实现类的对象."进行调用

实现类可以选择重写

4、公共的静态方法：public static， JDK1.8之后

只能使用”接口名.“进行调用

实现类不能重写

5、私有的方法：private（private不能省略）JDK1.9之后

实现接口

接口的使用，它不能创建对象，但是可以被实现（implements ，类似于被继承）。

一个类能同时实现多个接口

【修饰符】 class 实现类 [extends 父类] implements 接口1,接口2{　

　　// 重写接口中抽象方法【必须】
　　// 重写接口中默认方法【可选】default单词就不要再写了

}//继承在前，实现在后

实现类实现接口时，必须重写接口的所有抽象方法，否则实现类就必须是抽象类。

不能重写静态方法

如何调用对应的方法

• 对于接口的静态方法，直接使用“接口名.”进行调用即可

  • 也只能使用“接口名."进行调用，不能通过实现类的对象进行调用

• 对于接口的抽象方法、默认方法，只能通过实现类对象才可以调用

  • 接口不能直接创建对象，只能创建实现类的对象

接口的多实现

一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

方法可能有冲突问题：

（1）一个实现类实现了多个接口，而多个接口中出现了方法签名相同的默认方法时：

实现类必须做出选择：

A：保留其中一个：接口名.super.方法名

B：也可以完全重写

（2）一个实现类既继承父类，又实现接口，当父类中出现与接口的默认方法的方法签名相同的方法：

A：默认遵循亲爹原则，即保留父类的

B：也可以完全重写

接口的多继承

一个接口能继承另一个或者多个接口，接口的继承也使用 extends 关键字，子接口继承父接口的方法。

【修饰符】 interface 接口 extends 接口1,接口2{

}

小贴士：

子接口重写默认方法时，default关键字可以保留。

子类重写默认方法时，default关键字不可以保留。

接口与实现类对象的多态引用

实现类实现接口，类似于子类继承父类，因此，接口类型的变量与实现类的对象之间，也可以构成多态引用。通过接口类型的变量调用方法，最终执行的是你new的实现类对象实现的方法体。

经典接口

Comparable

第一步：哪个类的对象要比较大小，哪个类就实现java.lang.Comparable接口，并重写方法

第二步：对象比较大小时，通过对象调用compareTo方法，根据方法的返回值决定谁大谁小。

this对象（调用compareTo方法的对象）大于指定对象（传入compareTo()的参数对象）返回正整数

小于返回负数，等于返回0

    @Override
    public int compareTo(Object o) {
        //这些需要强制，将o对象向下转型为Student类型的变量，才能调用Student类中的属性
        Student stu = (Student) o;
        if(this.score != stu.score){
            return this.score - stu.score;
        }else{//成绩相同，按照学号比较大小
            return this.id - stu.id;
        }
    }

Comparator

第一步：编写一个类，我们称之为比较器类型，实现java.util.Comparator接口，并重写方法

第二步：比较大小时，通过比较器类型的对象调用compare()方法，将要比较大小的两个对象作为compare方法的实参传入，根据方法的返回值决定谁大谁小。

• o1对象大于o2返回正整数

• o1对象小于o2返回负整数

• o1对象等于o2返回零

    @Override
    public int compare(Object o1, Object o2) {
        Student s1 = (Student) o1;
        School s2 = (School) o2;
        //可比较2个不同类型对象的属性
        return s1.getId() - s2.getId();
    }        

抽象类与接口的区别

 1、 抽象层次不同。抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。

2、 跨域不同。抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分，然后泛化成抽象类，子类继承该父类即可，但是接口不同。实现它的子类可以不存在任何关系，共同之处。所以说抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a" 关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的， 仅仅是实现了接口定义的契约而已。

 3、 设计层次不同。对于抽象类而言，它是自下而上来设计的，我们要先知道子类才能抽象出父类，而接口则不同，它根本就不需要知道子类的存在，只需要定义一个规则即可，至于什么子类、什么时候怎么实现它一概不知。所以说抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。 

一个类对另外一个类的依赖性应当是建立在最小的接口上