09 继承

继承(1)   
 类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。
提高代码的复用性！
extends的意思是“扩展”。子类是父类的扩展

父类：超类、基类、 子类：派生类
 小结：
继承的作用：通过继承可以简化类的定义，实现代码的重用

子类继承父类的成员变量和成员方法，但不继承父类的构造方法

–java中只有单继承 ，没有像c++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。就像我们现实中，如果你有多个父母亲，那是一个多么混乱的世界啊。多继承，就是为了实现代码的复用性，却引入了复杂性，使得系统类之间的关系混乱。
–java中的多继承，可以通过接口来实现
–
如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object继继承(1) 


  子类可以继承父类的所有资源吗？
不能，不能被继承的父类成员有  1、private成员  2、子类和父类不再同包，使用默认访问权限的成员       3、构造方法

                  本类                    同包        子类           所有类
public               √                       √           √                   √            
Protected         √                   √           √                   ×            
默认                    √                   √            ×                    ×            
Private            √                   ×            ×                     ×    
package finaldemo;
/**
 * 1,用final来修饰一个变量， 则该变量就变成了一个常量
 * 2,用final来修饰一个类，则该类就不能被作为父类继承
 * 3,用final来修饰一个方法，则该方法就不能被重写
 * @author tang
 *
 */
public class Test {
    public static void main(String[] args) {
        final int AGE;
        AGE = 10;
        
    }
}    


方法的重写（override） 
在子类中可以根据需要对从基类中继承来的方法进行重写。
 重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。
重写方法不能使用比被重写方法更严格的访问权限。（由于多态）
package overwriter;

public class Pet {
    private String name;
    private int health;
    private int love;
    
    public Pet() {
        
    }
    
    public Pet(String name, int health, int love) {
        super();
        this.name = name;
        this.health = health;
        this.love = love;
    }
    public void print() {
        System.out.println(name + health + love);
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
}

package overwriter;
public class Cat extends Pet{
    private String color;    
    public Cat(String name, int health, int love, String color) {
        super(name, health, love);
        this.color = color;
    }
    public Cat() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public void print() {
        
        System.out.println();
        super.print();
    }
    
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

package overwriter;
public class Dog extends Pet {    
    //成员变量在最上面
    private String strain;
    //成员变量下面写构造方法
    public Dog() {
        
    }
    public Dog(String name, int health, int love, String strain) {
        super(name, health, love);
        this.strain = strain;
    }
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }    
}

package overwriter;

public class Test {
    public static void main(String[] args) {
        Dog wangcai = new Dog("旺财", 100, 100, "哈士奇");
        wangcai.print();
        
        Cat cat = new Cat("小黑", 100, 90, "黑色");
        cat.print();
    }
}

需要改写父类中方法的代码
package overwriter02;

public class Pet extends Object{
    private String name;
    private int health;
    private int love;
    
    public Pet() {
        
    }
    public Pet(String name, int health, int love) {
        super();
        this.name = name;
        this.health = health;
        this.love = love;
    }
    //宠物发出叫声的方法
    public void bark() {
        
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
}

package overwriter02;

public class Cat extends Pet{
    private String color;
    
    public Cat(String name, int health, int love, String color) {
        super(name, health, love);
        this.color = color;
    }
    public Cat() {
        super();
        // TODO Auto-generated constructor stub
    }

    @Override
    public void bark() {
        System.out.println("miao miao ...");
    }
    
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    
}


public class Dog extends Pet {
    
    //成员变量在最上面
    private String strain;
    //成员变量下面写构造方法
    public Dog() {
        
    }
    public Dog(String name, int health, int love, String strain) {
        super(name, health, love);
        this.strain = strain;
    }

    @Override
    public void bark() {
        super.bark();
        System.out.println("won won ...");
    }
    
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
}

package overwriter02;

public class Test {
    public static void main(String[] args) {
        
    }
}



为什么需要重写父类的方法?
父类实现的方法不符合子类的逻辑
父类已经实现了80%,但是子类又必须要使用剩下的20%,所以可以重写父类方法,在方法内用super关键字调用父类的方法,再去完成剩下的20%工作

super关键字 
定义：super是直接父类对象的引用。
用法：可以通过super来访问父类中被子类覆盖的方法或属性。
普通方法：
没有顺序限制。可以随便调用。
构造函数中： 
任何类的构造函数中，若是构造函数的第一行代码没有显式的调用super(...);那么Java默认都会调用super();作为父类的初始化函数。 所以你这里的super();加不加都无所谓。

final关键字  
定义：final可以用来修饰变量，方法，类。
修饰变量   变量一旦被初始化便不可改变 相当于定义了一个常量
             修饰引用数据类型  引用不能被赋值 但属性可以被赋值
修饰方法   final方法是在子类中不能被覆盖的方法
修饰类  final类是无法被任何类继承的
package finaldemo;
/**
 * 1,用final来修饰一个变量， 则该变量就变成了一个常量
 * 2,用final来修饰一个类，则该类就不能被作为父类继承
 * 3,用final来修饰一个方法，则该方法就不能被重写
 * @author tang
 *
 */
public class Test {
    public static void main(String[] args) {
        final int AGE;
        AGE = 10;
        
    }
}    
package finaldemo;

public  class Pet {
    public final void test() {
        System.out.println("test");
    }
}
package finaldemo;

public class Dog extends Pet{
    
}


Object类    
object类是所有java类的根基
如果在类的声明中未使用extends关键字指明其基类，则默认基类为object类
public class Person {
    ...
}
public class Person extends Object {
    ...
}
package objectdemo;

public class Dog {
    private String name;
    private int age;
    
    public Dog(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Dog() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    
    @Override
    public boolean equals(Object dog) {
        //做类型转换  将Object类型的参数转换为Dog类型的参数
        Dog dahuang = (Dog)dog;
        //如果两个对象的名字是相同的，则认为是相同的对象
        boolean b = this.name.equals(dahuang.name);
        return b;
    }

    //当使用system.out.println 来打印一个对象的时候   就是在答应对象toString方法的返回值
    @Override
    public String toString() {
        return "Dog [name=" + name + ", age=" + age + "]";
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
package objectdemo;
public class Test {
    public static void main(String[] args) {
        Dog wangcai = new Dog("旺财",11);
        Dog dahuang = new Dog("旺财", 10);
        
        System.out.println(wangcai.equals(dahuang));
        System.out.println(wangcai.toString());
    }
}


重写： toString 方法：
默认返回：包名+类名+@+哈希码
可以重写！

抽象类
定义：是一种模版模式。抽象类为所有子类提供了一个通用模版，子类可以在这个模版基础上进行扩展。
作用： 通过抽象类，可以避免子类设计的随意性。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。
package 抽象类;
/**
 * class 前加abstract 该类就成为了一个抽象类
 * 1，抽象类不能创建对象
 * 2，抽象类一般是一个父类，该父类没有什么存在的意义，就是用来被子类继承 
 * 3，抽象类中可以有抽象方法，也可以有非抽象方法
 * 4，一个类继承了一个抽象类，则该类必须要实现该抽象类中的所有抽象方法
 * 5，如果子类也是抽象类，则可以不实现父类的抽象方法
 * 6，抽象方法必须定义在抽象类中
 * 
 * 
 * 为什么要使用抽象类
 * 
 * @author tang
 *
 */
public abstract class Pet {
    private String name;
    //抽象方法
    //如果一个方法 每个子类实现的逻辑都不一样   则把该方法定义成抽象方法，
    //让每个子类去根据自己的逻辑实现该方法
    public abstract void bark();
    public abstract void eat();
    public abstract void sleep();
    public abstract void play();
    
    //如果一个方法，每个子类实现的逻辑都一样  则该方法直接在父类中实现，子类直接调用
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}

package 抽象类;

public class Dog extends Pet{

    @Override
    public void bark() {
        System.out.println("won won won...");
    }

    @Override
    public void eat() {
        System.out.println("狗喜欢吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗在睡觉。。。");
    }

    @Override
    public void play() {
        System.out.println("狗在玩飞盘。。。");
    }

}
package 抽象类;

public class Cat extends Pet{

    @Override
    public void bark() {
        System.out.println("maio miao ...");
    }

    @Override
    public void eat() {
        System.out.println("猫在吃鱼。。。");
        
    }

    @Override
    public void sleep() {
        System.out.println("猫在晒太阳。。。");
    }

    @Override
    public void play() {
        System.out.println("猫在玩老鼠。。。");
    }

}

总结：
抽象方法和抽象类均必须用abstract来修饰。
抽象方法没有方法体，只需要声明不需实现。
有抽象方法的类只能定义能抽象类
相反抽象类里面的方法不一定全是抽象方法，也可能没有抽象方法。
抽象类可以包含属性、方法、构造方法。
抽象类不能实例化，及不能用new来实例化抽象类，只能用来被子类调用。 
抽象类只能用来继承。
抽象方法必须被子类实现。抽象类的子类必须覆盖所有的抽象方法才能被实例化，否则还是抽象类
构造方法调用顺序：
根据super的说明，构造方法第一句 总是：super(…)来调用父类对应的构造方法。
先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止

对象的比较—==和equals()
==：
比较两基本类型变量的值是否相等
比较两个引用类型的值即内存地址是否相等，即是否指向同一对象
equals() ：
两对象的内容是否一致

自定义类须重写equals()，否则其对象比较结果总是false。
package equalsdemo;
/**
 * 判断相等的两种方式
 *
 *1， == 
 *    用来判断基本数据类型的数据是否相等
 *  也可以用来判断引用数据类型   判断两个引用是否相等  当且仅当两个引用指向的是同一个对象  == 判断才返回true
 *  
 *  
 *2，equals  
 *    判断引用数据类型的对象是否相等
 *    如果一个类没有重写该方法，则自动调用到Object中的equals  判断规则跟 == 一样
 *    如果要自定义判断相等的规则，则在本类中重写equals 方法，在方法内定义比较规则
 * @author tang
 *
 */
public class Test {
    public static void main(String[] args) {
        String str01 = "abc";
        String str02 = new String("abc");
        
        System.out.println(str01 == str02);
        System.out.println(str01.equals(str02));
        
    }
}