JAVA继承、抽象和接口总结

01 继承

1.示例代码

public class Account {

  public String username = "小程";
  private String password = "123";

  //Account的构造方法
  public Account(){
    System.out.println("Account的构造方法");
  }

  //Account的普通方法
  public void hello(){
    System.out.println("欢迎登陆");
  }
}

class MyAccount extends Account {

  //MyAccount的构造方法
  public MyAccount(){
    System.out.println("MyAccount的构造方法");
  }

  public static void main(String[] args) {
    MyAccount myAccount =  new MyAccount();
    myAccount.hello();
    System.out.println(myAccount.username);
    //System.out.println(myAccount.password); //报错：不能访问父类private成员变量
  }
}

2.运行结果

Account的构造方法
MyAccount的构造方法
欢迎登陆
小程

3.总结

1.子类拥有父类非private的属性，方法。
2. 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
3. 子类可以用自己的方式实现父类的方法。
4. Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
5. 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。

02 抽象

1.示例代码

//抽象类
public abstract class Fruits {
  String name= "水果";

  //Fruits的构造函数
  public Fruits() {
    System.out.println("Fruits的构造函数");
  }

  //普通方法
  public void buy(){
    System.out.println("买水果吃~~");
  }

  //抽象方法
  public abstract void taste();
}

//继承抽象类
public class Peach extends Fruits {
  //Test的构造函数
  public Peach() {
    System.out.println("Peach的构造函数");
  }

  //实现抽象方法
  @Override
  public void taste() {
    System.out.println("桃子尝起来是甜的");
  }

  public static void main(String[] args) {
    Peach peach =  new Peach();
    peach.buy();
    peach.taste();
    System.out.println(peach.name);
  }
}

2.执行结果

Fruits的构造函数
Peach的构造函数
买水果吃~~
桃子尝起来是甜的
水果

3.总结

1.抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
2.抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
3.构造方法，类方法（用static修饰的方法）不能声明为抽象方法。
5.抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
5.因为不能被实例化，所以只能被继承才能用，一个子类只能继承一个抽象类。

03 接口

1.示例代码

public class Watermelom extends Fruits implements SellNum, RemainNum {
  //Watermelom的构造函数
  public Watermelom() {
    System.out.println("Watermelom的构造函数");
  }

  //实现抽象方法
  @Override
  public void taste(){
    System.out.println("西瓜实现继承抽象类的抽象方法");
  }

  public static void main(String[] args) {
    Watermelom watermelom =  new Watermelom();
    watermelom.buy();
    watermelom.taste();
    watermelom.haveAmount();
    watermelom.selloutAmount();
    System.out.println(watermelom.name);
  }


  //implements必须实现接口
  @Override
  public void haveAmount() {
    System.out.println("实现了RemainNum接口的抽象方法haveAmount");

  }

  @Override
  public void selloutAmount() {
    System.out.println("实现了selloutAmount接口的抽象方法selloutAmount");

  }
}

public interface SellNum {
  //接口中变量会被默认指定为 public static final （并且只能是 public）。
  public static final int sellNumber =3;
  //或者这样写int sellnum = 1;一样的，会被默认指定。

  //接口中方法会被默认指定为 public abstract（只能是public abstract）。
  public abstract void selloutAmount();
  //或者这样写一样的void sellFruits();会被默认指定。
}

public interface RemainNum {
  // 接口中变量会被默认指定为 public static final （并且只能是 public）。
  public static final int remainNumber = 1;
  // 或者这样写int remainNumber =7;一样的，会被默认指定。

  // 接口中方法会被默认指定为 public abstract（只能是public abstract）。
  public abstract void haveAmount();
  // 或者这样写一样的void haveAmount();会被默认指定。
}

2.执行结果

Fruits的构造函数
Watermelom的构造函数
买水果吃~~
西瓜实现继承抽象类的抽象方法
实现了RemainNum接口的抽象方法haveAmount
实现了selloutAmount接口的抽象方法selloutAmount
水果

3.总结

1.接口不能用于实例化对象。
2.接口没有构造方法。
3.接口中所有的方法必须是抽象方法。
4.接口不能包含成员变量，除了 static 和 final 变量。
5.接口不是被类继承了，而是要被类实现，多实现用逗号隔开。
6.接口支持多继承。

4.接口特性

1.接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public
abstract，其他修饰符都会报错）。
2.接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用
private 修饰会报编译错误）。
3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

04 抽象类和接口的区别

1.抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。