Java---抽象类

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

我的主页：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;   // 颜色
}
1
2
3
4
5
6
7
8
9
10
11

抽象类特点

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

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

抽象方法不能是private修饰

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

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

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

//非法的修饰符组合: abstract和final
//非法的修饰符组合: abstract和static
1
2
3
4
5
6
7
8

抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 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
3
4
5
6
7
8
9
10
11
12

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

总结：

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

接口

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

语法规则

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

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

注意：

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

接口的使用

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

public  class 类名称 implements 接口名称{
  
}
1
2
3

注意：子类和父类之间是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());//匿名对象，只能使用一次
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

接口的特点

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

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

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

public interface USB {
  // 此处不允许使用修饰符private
  private void openDevice();
  void closeDevice();
}
1
2
3
4
5

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

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

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

public interface USB {
  void openDevice();
  void closeDevice();
  default void test(){
     System.out.println("default方法");  
  }
}
1
2
3
4
5
6
7

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

 public interface USB{
 void openDevice();   // 默认是public的
  void closeDevice();  // 默认是public的
}
public class Mouse implements USB {
  @Override
  void openDevice() {
    System.out.println("打开鼠标");
 }
 
  // ...
}
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 尝试分配更低的访问权限; 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

接口中可以含有变量，但是接口中的变量会被隐式的指定为 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属性 常量
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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

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

实现多个接口

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

通过类来表示动物：

class Animal {
protected String name;
 
  public Animal(String name) {
    this.name = name;
 }
}
1
2
3
4
5
6
7

定义两个接口：

interface IRunning {
  void run();
}
interface ISwimming {
  void swim();
}
1
2
3
4
5
6

创建一个具体的动物：

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 + "正在狗刨式游泳");
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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

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

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

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

接口使用实例

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;
      }
   } 
}
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在 sort方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象

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

1. 如果当前对象应排在参数对象之前, 返回小于 0 的数字;
2. 如果当前对象应排在参数对象之后, 返回大于 0 的数字;
3. 如果当前对象和参数对象不分先后, 返回 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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

抽象类和接口的区别

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

Object类

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

获取对象信息

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

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

对象比较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 ;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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

完结

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

下期预告：java—String类