乐观学习，乐观生活，才能不断前进啊！！！

我的主页：optimistic_chen
我的专栏：c语言 ，Java
欢迎大家访问~
创作不易，大佬们点赞鼓励下吧~

抽象类

什么的抽象类？

在Java中，所以对象都是通过类来描述的，但是反过来，并不是所有类都是用来描述对象的。如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

说明：
1.猫、狗、牛都是动物，因此和Animal类是继承关系
2.虽然动物类中也存在eat()方法，但是它不是具体的动物，没有具体的对象，因此其内部的eat()方法没有办法实现。
3.因为Animal类没有办法描述一个具体的类，所以可以将Animal类设计为“抽象类”。

主要的eat方法都是由 Animal 的各种子类的 eat 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法(abstract method), 包含抽象方法的类我们称为 抽象类(abstract class).

抽象类语法

在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

// 抽象类：被abstract修饰的类
public abstract class Animal {// 抽象方法：被abstract修饰的方法，没有方法体abstract public void eat();// 抽象类也是类，也可以增加普通方法和属性public String  Color(){return black;}protected String color;   // 颜色
}

抽象类特点

抽象类不能直接实例化对象

Animal animal = new Aniaml();//编译报错
//Animal是抽象的，无法实例化

抽象方法不能是private修饰

abstract class Animal {abstract private void eat();
}//编译错误
//非法修饰符组合 abstract 和 private

抽象方法不能被final和static修饰，因为抽象方法要被子类重写(Java—多态)

//前面说过，抽象类需要继承子类对象来实现抽象方法，所以抽象方法要被子类重写
public abstract class Shape {abstract final void methodA();abstract public static void methodB();
}//编译错误//非法的修饰符组合: abstract和final
//非法的修饰符组合: abstract和static

抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰

// 矩形类
public class Cat extends Animal {private String color;private double weigth;Cat(String color, double weigth){this.color = color;this.weigth = weigth;}public void eat(){System.out.println("cat：color= "+color+"cat： weigth= " + weigth);}
}

抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

总结：

1. 抽象类本身不能被实例化, 要想使用, 只能创建该抽象类子类. 然后让子类重写抽象类中的抽象方法.
2. 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题

接口

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。
在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

语法规则

将class关键字换成 interface 关键字，就定义了一个接口

public interface 接口名称{// 抽象方法public abstract void method1();  // public abstract 是固定搭配，可以不写void method2();// 注意：在接口中上述写法都是抽象方法，推荐方式2，代码更简洁
}

注意：

1. 创建接口时, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 “形容词” 词性的单词.
3. 接口中的方法和属性最好不要加任何修饰符号, 保持代码的简洁性.

接口的使用

接口不能直接使用，必须要有一 "实现类"来"实现"该接口，实现接口中的所有抽象方法

public  class 类名称 implements 接口名称{}

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系

// USB接口
public interface USB {void openDevice();void closeDevice();
}
// 鼠标类，实现USB接口
public class Mouse implements USB {
//抽象方法@Overridepublic void openDevice() {System.out.println("打开鼠标");}@Overridepublic void closeDevice() {System.out.println("关闭鼠标");}public void click(){System.out.println("鼠标点击");}
}//测试
public class TestUSB {public static void main(String[] args) {Computer computer = new Computer();// 使用鼠标设备computer.useDevice(new Mouse());//匿名对象，只能使用一次}
}

接口的特点

接口类型是一种引用类型，但是不能直接new接口的对象

public class TestUSB {public static void main(String[] args) {USB usb = new USB();}//编译错误
}

接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstrac（只能是public abstract，其他修饰符都会报错）

public interface USB {// 此处不允许使用修饰符privateprivate void openDevice();void closeDevice();
}

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

public interface USB {void openDevice();void closeDevice(){System.out.println("关闭设备");
}

如果接口当中的方法被default修饰，可以有具体的实现

public interface USB {void openDevice();void closeDevice();default void test(){System.out.println("default方法");  }
}

重写接口中方法时，不能使用默认的访问权限

 public interface USB{void openDevice();   // 默认是public的void closeDevice();  // 默认是public的
}
public class Mouse implements USB {@Overridevoid openDevice() {System.out.println("打开鼠标");}// ...
}
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 尝试分配更低的访问权限; 

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

public interface USB {double brand = 3.0;  // 默认被：final public static修饰void openDevice();void closeDevice();
}
public class TestUSB {public static void main(String[] args) {System.out.println(USB.brand);  // 可以直接通过接口名访问，说明是静态的// 编译报错：无法为最终变量brand分配值USB.brand = 2.0;    // 说明brand具有final属性 常量}
}

接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。

通过类来表示动物：

class Animal {
protected String name;public Animal(String name) {this.name = name;}
}

定义两个接口：

interface IRunning {void run();
}
interface ISwimming {void swim();
}

创建一个具体的动物：

class Dog extends Animal implements IRunning,ISwimming {public Cat(String name) {super(name);//动态绑定}@Overridepublic void run() {System.out.println(this.name + "正在用四条腿跑");}@Overridepublic void swim() {System.out.println(this.name + "正在狗刨式游泳");}
}

时刻牢记多态的好处, 忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力。

public static void walk(IRunning running) {System.out.println("我带着伙伴去散步");running.run();
}

在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的

Cat cat = new Cat("小猫");
walk(cat);//小猫正在用四条腿跑

接口使用实例

Comparable接口

正常情况下，我们通常使用sort函数实现大小比较，那如果我们自定义一个类型，让它来进行大小的比较，那么就必须实现Comparable接口。

//class Student implements Comparable<Student>//泛型，比较哪个类写那个类
class Student implements Comparable {private String name;private int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return "[" + this.name + ":" + this.score + "]";}@Overridepublic 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 类型的对象

比较当前对象和参数对象的大小关系(按分数来算).

1. 如果当前对象应排在参数对象之前, 返回小于 0 的数字;
2. 如果当前对象应排在参数对象之后, 返回大于 0 的数字;
3. 如果当前对象和参数对象不分先后, 返回 0;

Clonable接口

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”. 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出CloneNotSupportedException 异常

class Animal implements Cloneable {private String name;@Overridepublic Animal clone() {Animal o = null;try {o = (Animal)super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();}return o;}
}
public class Test {public static void main(String[] args) {Animal animal = new Animal();Animal animal2 = animal.clone();//克隆一个对象System.out.println(animal == animal2);//比较地址}
}

抽象类和接口的区别

核心区别：
抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写) , 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.

	区别	抽象类	接口
1	结构组成	普通类+抽象方法	抽象方法+全局常量
2	权限	各种权限	public
3	子类使用	使用extends关键字继承抽象类	使用implements关键字实现接口
4	关系	一个抽象类可以实现多个接口	接口不能继承抽象类，但是接口可以使用extends关键字继承多个父类接口
5	子类限制	一个子列只能继承一个抽象类	一个子类可以实现多个接口

Object类

Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。

获取对象信息

如果要打印对象中的内容，可以直接重写Object类中的toString()方法。

// Object类中的toString()方法实现：
public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

对象比较equals方法

在Java中，== 进行比较时
a.如果 == 左右两侧是基本类型变量，比较的是变量中值是否相同
b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的

class Person{private String name ;private int age ;public Person(String name, int age) {this.age = age ;this.name = name ;}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false ;
}
if(this == obj) {
return true ;
}
// 不是Person类对象
if (!(obj instanceof Person)) {
return false ;
}Person person = (Person) obj ; // 向下转型，比较属性值
return this.name.equals(person.name) && this.age==person.age ;}
}

结论：比较对象中内容是否相同的时候，一定要重写equals方法。

完结

好了，这期的分享到这里就结束了~
如果这篇博客对你有帮助的话，可以点一个免费的赞并收藏起来哟~
可以点点关注，避免找不到我~
我们下期不见不散~~

下期预告：java—String类