目录
一. 抽象类
1.1 抽象类的概念
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。例如：
说明：
1.Animal类是动物类，每个动物都有叫的方法，但是Animal不是一个具体的动物，因此其内部的bark()方法无法具体实现。
2.Dog是狗类继承Animal类，狗是一个具体的动物，狗叫“旺旺”，其bark()可以实现。
3.Cat是猫类继承Animal类，猫是一个具体的动物，猫叫“喵喵”，其bark()可以实现。
4.因此Animal可以设计为“抽象类”。
没有实际的工作方法，我们可以把它设计为抽象方法，包含抽象方法的类称为“抽象类”。
1.2 抽象类的语法
在Java中一个类被 abstract 修饰称为抽象类，抽象类中被abstract修饰的方法被称为抽象方法，抽象方法不用给出具体的实现体。
public abstract class Animal { //抽象类，被abstract修饰
abstract void eat(); //抽象方法，被abstract修饰没有方法体
abstract void sleep();
public void run(){ //也可以增加普通方法和属性
System.out.println("跑");
}
}注意：抽象类也是类，内部可以包含普通方法和属性和构造方法
1.3 抽象类特性
1.抽象类不能直接实例化对象
Animal animal = new Animal();
//编译报错，因为Animal是抽象的无法实例化2.抽象方法不能被private修饰
abstract private void eat();
//编译报错，非法的修饰符组合：abstract和private注意：抽象方法没有加访问访问修饰符，默认是public.
3.抽象方法不能被final和static修饰，因为抽象方法要被子类重写
abstract final void eat();
abstract static void sleep();
//编译报错，非法的修饰符组合4.抽象类必须被继承，并且被继承后子类要重写父类中所有的抽象方法，否则子类也是抽象类，必须要用abstract修饰
public abstract class Animal {
abstract void eat();
abstract void sleep();
}
public class Dog extends Animal {
@Override
void eat() {
}
@Override
void sleep() {
}
}
public abstract class Cat extends Animal{
@Override
void eat() {
}
}5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量
1.4 抽象类的作用
抽象类本身不能被实例化，要想使用只能创建该抽象类的子类，然后让那个子类重写父类中的抽象方法。
使用抽象类，实际工作不由父类完成，而应由子类完成，如果此时不小心误用父类了，使用普通类编译器不会报错，但是父类是抽象类就会在实例化的时候提示错误，让我们尽早发现问题。
二. 接口
2.1 接口的概念
现实生活中接口的例子很多，比如电脑上的USB接口，电源插座等。
电脑的USB口可以插：U盘，鼠标键盘，所有符合USB协议的设备
电源的插座可以插：电脑，电视机，电饭煲，所有符合规范的设备
上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合标准就可以通用。在Java中，接口可以看成：多个类的公共规范，是一种引用数据类型。
2.2 语法规则
接口的定义格式与类的定义格式基本相同，将class关键字换成interface关键字，就定义了一个借口。
public interface 接口名称{
public abstract void method1(); //public abstract是固定搭配，可以省略不写
public void method2();
abstract void method3();
void method4(); //推荐这种风格
}提示：
1. 创建接口时，接口的命名一般以大写字母I开头
2. 接口命名一般使用形容词词性的单词
3. 阿里编码规范中规定，接口中的方法属性不要加任何修饰符号，保持代码的简洁性
2.3 接口使用
接口不能直接使用，必须有一个实现类来实现该接口，实现接口中的所有抽象方法，这里使用关键字implements来实现。
public class 类名称 implements 接口名称{
//......
}
注意：子类父类是extends继承关系，接口与类之间是implements实现关系。
例子：
实现笔记本电脑使用USB鼠标，USB键盘的例子
1.USB接口：包含打开设备，关闭设备功能
2.笔记本类：包含开机功能，关机功能，使用USB设备功能
3.鼠标类：实现USB接口，并具备点击功能
4. 键盘类：实现USB接口，并具备输入功能
//USB接口
public interface USB {
void openDevice();
void closeDevice();
}
//鼠标类
public class Mouse implements USB{
@Override
public void openDevice() {
System.out.println("打开鼠标");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标");
}
public void click(){
System.out.println("点击鼠标");
}
}
//键盘类
public class KeyBoard implements USB{
@Override
public void openDevice() {
System.out.println("打开键盘");
}
@Override
public void closeDevice() {
System.out.println("关闭键盘");
}
public static void inPut(){
System.out.println("键盘输入");
}
}
//电脑类使用USB设备
public class Computer {
public void powerOn(){
System.out.println("打开笔记本电脑");
}
public void powerOff(){
System.out.println("关闭笔记本电脑");
}
public void useDevice(USB usb){
usb.openDevice();
if(usb instanceof Mouse){
Mouse mouse = (Mouse)usb;
mouse.click();
}else if(usb instanceof KeyBoard){
KeyBoard keyboard = (KeyBoard)usb;
KeyBoard.inPut();
}
usb.closeDevice();
}
}
//测试类
public class TestUSB {
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
computer.useDevice(new Mouse());
computer.useDevice(new KeyBoard());
computer.powerOff();
}
}
2.4 接口特性
1. 接口是一种引用类型，但是不能直接new接口对象
public class TestUSB {
public static void main(String[] args) {
USB usb = new USB() ; //编译报错：USB是抽象的，无法实例化
}2. 接口中的每一个方法都是public的抽象方法，即接口中东非方法会隐式的指定为public abstract（只能是这种，其他修饰符都会报错）
3. 接口中的方法不能在接口中实现，只能由实现接口的类来实现
public interface USB {
void openDevice();
void closeDevice(){
System.out.println("关闭设备"); //编译错误，接口中的方法默认为抽象方法
}
}
4.重写接口方法时不能使用default访问权限修饰符
5.接口中可以含有变量，但接口中的变量会被隐式的指定为public static final 变量
6.接口中不能有静态代码块和构造方法
7.接口虽然不是类，但是编译完成后的字节码文件的后缀也是.class
8.如果类没有实现结合中的所有抽象方法，则类必须设置为抽象类
2.5 实现多个接口
在Java中类是单继承的，但是一个类可以实现多个接口
下面通过类表示一组动物
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}提供接口表示游，飞，跑
public interface ISwimming {
void swim();
}
public interface IFlying {
void fly();
}
public interface IRunning {
void run();
}猫会跑
public class Cat extends Animal implements IRunning{
public Cat(String name){
super(name);
}
@Override
public void run() {
System.out.println(this.name+"正在跑");
}
}
鱼会游
public class Fish extends Animal implements ISwimming{
public Fish(String name){
super(name);
}
@Override
public void swim() {
System.out.println(this.name+"正在游");
}
}
青蛙能跑能游
public class Frog extends Animal implements IRunning,ISwimming{
public Frog(String name){
super(name);
}
@Override
public void run() {
System.out.println(this.name+"正在跑");
}
@Override
public void swim() {
System.out.println(this.name+"正在游");
}
}注意：一个类在实现接口时，每个接口的抽象方法都要实现，否则必须设置成抽象类
鸭子：水陆空三栖动物
public class Duck extends Animal implements ISwimming,IRunning,IFlying{
public Duck(String name){
super(name);
}
@Override
public void fly() {
System.out.println(this.name+"在空中飞");
}
@Override
public void run() {
System.out.println(this.name+"在地上跑");
}
@Override
public void swim() {
System.out.println(this.name+"在水里游");
}
}
2.6 接口间的继承
在Java中类与类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承，
接口之间可以继承，达到复用的效果，使用 extends 关键字。
public interface IRunning {
void run();
}
public interface ISwimming {
void swim();
}
public interface IAmphibious extends IRunning,ISwimming{
}
class Frog implements IAmphibious{
}通过接口继承，创建一个新的接口IAmphibious表示“两栖的”，此时实现接口创建的Frog类就要实现run方法，还要实现swim方法。
接口间的继承相当于把多个接口合并起来
2.7 接口之间的实例
给对象数组排序
public class Student {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "["+this.name+":"+this.score+"]";
}
在给定一个学生对象数组，对这个数组中的元素进行排序
Student[] students = new Student[] {
new Student("张三",92),
new Student("李四",94),
new Student("王五",90),
};数组有一个sort方法，能否直接用这个方法呢？
Arrays.sort(students); //编译报错
System.out.println(Arrays.toString(students));
普通整数可以直接比较，而两个学生对象的大小关系怎么确定？需要额外指定
让student类实现Comparable接口，并实现其中的compareTo方法
public class Student implements Comparable{
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "["+this.name+":"+this.score+"]";
}
@Override
public int compareTo(Object o){
Student s = (Student)o;
if(this.score>s.score){
return -1;
}else if(this.score<s.score){
return 1;
}else {
return 0;
}
}在sort方法中会自动调用compareTo方法，compareTo的参数是Object，其实传入的就是student类的对象，然后比较当前对象和参数对象的大小关系（按分数来算）。
· 如果当前对象应排在参数对象之前，返回小于0的数字
· 如果当前对象应排在参数对象之后，返回大于0的数字
· 如果当前对象和参数对象部分前后，返回0
注意事项：对于sort来说，需要传入的数组的每个对象都是可比较的，需要具备compareTo这样的能力，通过重写compareTo就可以定义比较规则。
再次执行代码的结果：
2.8 抽象类和接口的区别
抽象类和接口都是Java中多态的常见使用方式
主要区别：抽象类中可以包含普通字段和普通方法，这样的字段和方法可以被子类直接使用（不必重写），接口中不能包含普通方法，子类必须重写其所有抽象方法
提醒：
抽象类的存在是为了让编译器更好的校检，像Animal这样的类我们不会直接使用，而是直接使用子类，如果不小心创建了Animal实例，编译器会及时提醒我们
| 区别 | 抽象类 | 接口 |
| 结构组成 | 普通类+抽象方法 | 抽象方法+全局变量 |
| 权限 | 各种权限 | public |
| 子类使用 | extends关键字 | implements关键字 |
| 关系 | 一个抽象类可以实现多个接口 | 接口可以继承多个接口 |
| 子类限制 | 一个子类只能继承一个抽象类 | 一个子类可以实现多个接口 |
3. Object类
3.1 使用Object接收所有类的对象
Object类是所有类的父类，所有类都继承Object类，即所有类的对象都可以使用Object的引用进行接收。
范例：使用Object接收所有类的对象
class person{}
class student{}
public class Test {
public static void main(String[] args) {
function(new person());
function(new student());
}
public static void function(Object obj){
System.out.println(obj);
}
}
//执行结果
day20211026.person@1b6d3586
day20211026.student@4554617c3.2 对象比较equals方法
在Java中，== 进行比较时：
1. 如果“==”左右两侧是基本类型变量，比较变量的值是否相同
2. 如果“==”左右两侧是引用类型变量，比较引用变量的地址是否相同
3.如果要比较对象中的内容，就要重写Object中的equals方法，因为equals方法也默认是按照地址来进行比较的
//Object类中的equals方法
public boolean equals(Object obj){
return (this==obj); //使用引用中的地址直接来进行比较
}class Person{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
public class Test1 {
public static void main(String[] args) {
Person p1 = new Person("XiaoZhang",20);
Person p2 = new Person("XiaoZhang",20);
int a = 10;
int b = 10;
System.out.println(a==b); //true
System.out.println(p1==p2); //false
System.out.println(p1.equals(p2)); //false
}
}重写equals方法，然后进行比较：
@Override
public boolean equals (Object obj){
if(obj==null){
return false;
}
if(this==obj){
return true;
}
if(!(obj instanceof Person)){
return false;
}
Person person = (Person)obj;
return this.name.equals(person.name)&&this.age==person.age;
}结论：比较对象中内容的时候，一定要重写equals方法。
3.3 hashCode方法
程序中new一个对象，JVM会以哈希表的方式将对象管理起来，下次比较或者取对象得时候，会依据对象的hashCode再从哈希表中取，目的是为了提高获取对象的效率。
hashCode方法源码：
public native int hashCode();该方法是一个native方法，底层是由c++/c代码写的。
我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashCode()方法，我们可以来看示例代码：
class Person{
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
Person p1 = new Person("XiaoGao",20);
Person p2 = new Person("XiaoGao",20);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
}
}
//执行结果
460141958
1163157884注意事项：两个对象的hash值不一样
重写hashCode()方法：
@Override
public int hashCode(){
return Objects.hash(name,age);
}执行结果：
哈希值结果相同
结论：
1. hashCode方法用来确定对象在哈希表中存储位置
2. 事实上hashCode()在散列表中才有用，在其他情况下没用，在散列表中hashCode()的作用是获取对象的散列码，进而确定该对象在散列表中的位置。
3.4 接收引用类型数据类型
前面已经分析了Object可以接收任意的对象，因为Object是所有类的父类，但是Object并不局限于此，它可以接收所有数据类型，包括：类，数组，接口
范例：使用Object接收数组对象
Object obj = new int[]{1,2,3,4,5};
int[] data = (int[])obj;
for(int i : data){
System.out.println(i+" ");
}范例：使用Object接收接口对象
interface ImMessage{
public void getMessage();
}
class MessageImpl implements ImMessage{
@Override
public String toString(){
return "我是中国人";
}
public void getMessage() {
System.out.println("中国欢迎你");
}
}
public class Test1 {
public static void main(String[] args) {
ImMessage msg = new MessageImpl();
Object obj = msg;
System.out.println(obj);
ImMessage temp = (ImMessage) obj;
temp.getMessage();
}
}
Object真正达到了参数的统一，如果一个类希望接收所有的数据类型，就是用Object完成，在Java中，底层就是通过Object来实现的。
4047
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
