面向对象之继承

1. 单继承

Java继承是单继承（只有一个父类），派生类与基类的IS-A关系（即“猫”is a“动物”）。

2. 继承的好处

子类拥有父类的所有属性和方法(属性和方法的修饰符不能是private)
实现代码复用

3. 语法规则

Class 子类 extends 父类
例如：
class Dog extends Animal{
…..
}

4. 方法的重写

子类可以对继承父类的方法进行重写，调用方法时，优先调用子类的方法。
重写的要求：
返回值类型、方法名、参数类型和个数都要与父类继承的方法相同。

父类
package duotai;
public class Transportation {
    public String transport;
    public int maxnum;
    public void detail() {
        System.out.println("detail:"+transport+"-" + maxnum);
子类
package duotai;
public class Bus extends Transportation {
    public void detail() {
        System.out.println("busdetail:"+transport+"-" + maxnum);

5. 抽象类

1. 应用场景：约束类的方法，不约束方法的实现
   
   • 父类知道子类包含哪些方法，但是父类不知道子类如何实现这些方法。
   • 多个相同特征的类中抽象出一个抽象类，以这个抽象类为子类的模板，避免子类设计的随意性。
2. 使用规则
   
   • Abstract定义抽象类。
   • Abstract定义抽象方法，只有声明，不需要实现。
   • 包含抽象方法的类是抽象类。
   • 抽象类中可以包含普通的方法，也可以没有抽象的方法。
   • 抽象类不能直接创建，可以定义引用变量。

抽象类：shape 子类：rectangle、circle

抽象类：shape
public abstract class shape {
//抽象方法没有方法体以分号结束
    public abstract void length();
    public abstract void area();
}
子类：rectangle
public class rectangle extends shape {
    public void length() {
        System.out.println("lengtg of Rectangle");
    }
    public void area() {
        System.out.println("area of Rectangle");
    }
}
子类：circle
public class circle extends shape {
    public void length() {
        System.out.println("lengtg of Circle");
    }
    public void area() {
        System.out.println("area of Circle");
    }
}
主函数
public class Initail {
    public static void main(String[] args) {
        shape sha1 = new rectangle();
        sha1.length();
        sha1.area();
        shape sha2 = new circle();
        sha2.length();
        sha2.area();
    }
}

6 继承的初始化顺序

7 final关键字

final与类、方法、属性、变量的关系

final修饰类：该类不允许被继承。
final修饰方法：该方法不允许被重写（覆盖）
final修饰属性：
该类的属性不能隐性初始化，即：类的初始化属性必须有值。
或在构造方法中赋值。
final修饰变量，这变量的值只能赋值一次不可改变。即为常量

8 super关键字

在JAVA类中使用super来引用父类的成分，用this来引用当前对象。

父类
public class Animal {
    public int num = 10;
    public String driver;
    public void car(){
        System.out.println("super.DriverNumIs:"+num);
    }
}
子类
public class Dog extends Animal {
    public int num = 20 ;
    //重写方法
    public void car() {
        System.out.println("DriverNumIs:"+num);
    }
    public void method() {
        System.out.println("num is:"+num);//子类的值
        System.out.println("spuer.num is:"+super.num);//super调用父类的值
        car();
        super.car();//通过super调用父类的方法
    }
}
初始化：
public class Init_pro {
    public static void main(String[] args) {
        Dog dog =new Dog();
        dog.method();
    }
}
结果：
num is:20
spuer.num is:10
DriverNumIs:20
super.DriverNumIs:10

9 Object类(所有类的父类)

1. toString() 方法
   在object类里面定义toString( )方法的时候返回的对象的哈希码（对象地址字符串）

    public static void main(String[] args) {
        Dog dog =new Dog();
        System.out.println(dog);
    }
    结果 ：
    com.jicheng.Dog@659e0bfd

1. equals( )方法
   比较对象的引用是否指同一块内存地址。返回值是布尔类型.

    public static void main(String[] args) {
        Dog dog =new Dog();
        Dog dog2 = new Dog();
        if(dog.equals(dog2)){
            System.out.println("Same");
        }else {
            System.out.println("Dif");
        }
    }
结果：Dif

两个方法都能在source菜单栏里面自动生成。
关于自动生成的equals( )方法的说明

    public boolean equals(Object obj) {
        if (this == obj) //对象的地址是否相同
            return true;
        if (obj == null) //其中一个地址为空
            return false;
        if (getClass() != obj.getClass()) 
        //得到一个类对象具体见下图
            return false;
        Dog other = (Dog) obj; //转换成Dog类
        if (num != other.num)
            return false;
        return true;
    }
在子类中重写equals()方法后，能够比较类中变量的数值是否相同。

java中的数据类型，可分为两类：
1. 基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
他们之间的比较，应用双等号（==）,比较的是他们的值。
2. 复合数据类型(类)
当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被覆盖（重写）掉了。（==）是无法重写的。
==比较的是2个对象的地址，而equals比较的是2个对象的内容。