继承（extends）

继承的作用

基本作用

子类继承父类，代码可以得到复用。

主要（重要）作用

因为了有了继承机制，才有了后期的方法覆盖和多态。

继承的相关特性

1. B类继承A类，则称A类为超类(superclass)、父类、基类，B类则称为子类(subclass)、派生类、扩展类。

   class A{
   ​
   } 
   ​
   class B extends A{
   ​
   }

    

2. Java中的继承只支持单继承，不支持多继承，C++中支持多继承，这也是java体现简单性的一点，换句话说，java中不允许这样写代码: class B extends A,C{ }。

3. 虽然Java中不支持多继承，但有的时候会产生间接继承的效果，例如:

   class A{
   ​
   }
   class B extends A{
   ​
   }
   class C extends B{
   ​
   }
   //class C extends B， class B extends A，也就是说，C直接继承B，其实C还间接继承A。

    

4. Java中规定，子类继承父类，除构造方法不能继承之外，剩下都可以继承。但是私有的属性无法在子类中之直接访问（可以通过间接访问，也就是父类中的setter或getter方法）。

5. Java中的类没有显示的继承任何类，则默认继承object类，object类是 java语言提供的根类（老祖宗类），也就是说，一个对象与生俱来就有object类型中所有的特征。

    

6. 继承也存在一些缺点，例如:creditAccount类继承Account类会导致它们之间的耦合度非常高，Account类发生改变之后会马上影响到creditAccount类。

   package com.liu.jicheng;
   ​
   public class ExtendsTest01 {
       public static void main(String[] args) {
           Account account=new Account("1000",1000);
           CreditAccount creditAccount=new CreditAccount("2000",2000,0.99);
           System.out.println("账号："+account.getAcnno()+" 余额："+account.getBalance());
           System.out.println("账号："+creditAccount.getAcnno()+" 余额："+creditAccount.getBalance()+" 信誉度："+creditAccount.getCredit());
       }
   ​
   }
   ​
   //普通账户类
   class Account{//父类,默认继承Object，Object是所有类的祖宗
       //账号
       private String acnno;
       //余额
       private double balance;
       //无参构造
       public Account(){
   ​
       }
       //有参构造
       public Account(String acnno, double balance) {
           this.acnno = acnno;
           this.balance = balance;
       }
       //setter and getter 方法
       public String getAcnno() {
           return acnno;
       }
   ​
       public void setAcnno(String acnno) {
           this.acnno = acnno;
       }
   ​
       public double getBalance() {
           return balance;
       }
   ​
       public void setBalance(double balance) {
           this.balance = balance;
       }
   }
   ​
   class CreditAccount extends Account{//子类继承父类 ，父类中的所有属性、方法（构造方法除外）都传递到了子类中
       //信誉度
       private double credit;
       //无参
       public CreditAccount(){
   ​
       }
       //有参
       public CreditAccount(String acnno, double balance, double credit) {
           /*这样写不太好
               this.setAcnno(acnno);
               this.setBalance(balance);
            */
           super(acnno, balance);
           this.credit = credit;
       }
   ​
       //setter and getter 方法
       public double getCredit() {
           return credit;
       }
   ​
       public void setCredit(double credit) {
           this.credit = credit;
       }
       public void dosome(){
           //System.out.println(acnno);//编译不通过
           System.out.println(getAcnno());
       }
   }

什么时候使用继承

凡是使用”is a“描述的都可以使用继承。例如：

• Cat is a Animal：猫是一个动物；

• Dog is a Animal：狗是一个动物；

• CreditAccount is a Account ：信誉账户是一个银行账户。

• ....................................

假设以后的开发中有一个A类，有一个B类，A类和B类确实用重复的代码，但是他们俩之间不是”is a”的关系，不建议使用继承；例如：

class Customer{
    String name;//姓名
}
class Product{
    Stirng name;
}

Object提供了哪些方法

String是sun公司编写的字符串类、System是sun编写的系统类。

println

System.out.println("Hello world");
/*
    System.out 中out没有括号切变量名首字母小写，即out是一个变量名
    另外System是类名，直接使用System.out说明out是静态变量。
    System.out 返回一个对象，然后采用“对象.”的方式去调用println()方法
*/
//类似的例子
public class Println {
    public static void main(String[] args) {
        Test.d.dosome();//！！！！！！！
    }
}
class Test{
    static Dosome d=new Dosome();
}
​
class Dosome{
    public void dosome(){
        System.out.println("做事情");
    }
}

Object源码

public class Object {
    //当源码中的一个方法以“；”结尾，并且修饰符列表中有“native”这个关键字，表示调用底层c++写的dll程序（dll动态链接库文件）
    private static native void registerNatives();
    static {
        registerNatives();
    }
​
    public final native Class<?> getClass();
​
    public native int hashCode();
​
    public boolean equals(Object obj) {
        return (this == obj);
    }
    //已有对象a，想创建一个和a一摸一样的对象可以调用这个clone方法，底层也是c++。
    protected native Object clone() throws CloneNotSupportedException;
    
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
​
    public final native void notify();
​
    public final native void notifyAll();
​
    public final native void wait(long timeout) throws InterruptedException;
​
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
​
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
​
        if (nanos > 0) {
            timeout++;
        }
​
        wait(timeout);
    }
    public final void wait() throws InterruptedException {
        wait(0);
    }
    protected void finalize() throws Throwable { }
}
​

toString

当直接输出一个引用的时候会自动调用toString方法

public class ToStringTest {
    public static void main(String[] args) {
        ToS toS=new ToS();
        System.out.println(toS);//输出ToS@1b6d3586
        System.out.println(toS.toString());//输出ToS@1b6d3586
    }
}
​
class ToS{
    
}