Java---抽象类

07-21 1624阅读

Java---抽象类 乐观学习，乐观生活，才能不断前进啊！！！

我的主页：optimistic_chen

我的专栏：c语言 ，Java

欢迎大家访问~

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

文章目录

  • 抽象类
    • 什么的抽象类？
    • 抽象类语法
    • 抽象类特点
    • 接口
      • 语法规则
      • 接口的使用
      • 接口的特点
      • 实现多个接口
      • 接口使用实例
        • Comparable接口
        • Clonable接口
        • 抽象类和接口的区别
        • Object类
          • 获取对象信息
          • 对象比较equals方法
          • 完结

            抽象类

            什么的抽象类？

            在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 {
//抽象方法
  @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//泛型，比较哪个类写那个类
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  
 
 
            在 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权限各种权限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类

VPS购买请点击我

文章版权声明：除非注明，否则均为主机测评原创文章，转载或复制请以超链接形式并注明出处。

相关阅读

目录[+]