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

我的主页：optimistic_chen

我的专栏：c语言 ，Java

欢迎大家访问~

创作不易，大佬们点赞鼓励下吧~

文章目录

抽象类什么的抽象类？抽象类语法抽象类特点

接口语法规则接口的使用接口的特点实现多个接口接口使用实例Comparable接口Clonable接口

抽象类和接口的区别Object类获取对象信息对象比较equals方法

完结

抽象类

什么的抽象类？

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

说明：

1.猫、狗、牛都是动物，因此和Animal类是继承关系

2.虽然动物类中也存在eat()方法，但是它不是具体的动物，没有具体的对象，因此其内部的eat()方法没有办法实现。

3.因为Animal类没有办法描述一个具体的类，所以可以将Animal类设计为“抽象类”。

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

抽象类语法

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

<code>// 抽象类：被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);

}

}

抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

总结：

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

接口

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

语法规则

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

public interface 接口名称{

// 抽象方法

public abstract void method1(); // public abstract 是固定搭配，可以不写

void method2();

// 注意：在接口中上述写法都是抽象方法，推荐方式2，代码更简洁

}

注意：

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

接口的使用

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

public class 类名称 implements 接口名称{

}

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

// USB接口

public interface USB {

void openDevice();

void closeDevice();

}

// 鼠标类，实现USB接口

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 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 {

// 此处不允许使用修饰符private

private 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 {

@Override

void 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);//动态绑定

}

@Override

public void run() {

System.out.println(this.name + "正在用四条腿跑");

}

@Override

public 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;

}

@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;

Clonable接口

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

class Animal implements Cloneable {

private String name;

@Override

public 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类