Day 7 面向对象2

继承的格式与利弊

继承的格式：
    public class 子类名extends 父类名{}

继承的好处：
    A:提高了代码的复用性
    B:提高了代码的维护性
    C：让类与类之间产生了关系，是多态的前提

继承的弊端：
    让类与类之间产生了关系，也就是让类的耦合性增强了。

//java中类只支持单继承，不支持多继承。

//java支持多层继承

    开发原则：高内聚，低耦合
        内聚：就是自己完成某件事的能力
        耦合：类与类的关系
        
        java 继承中成员变量的特点
        A:成员变量名称不一样，使用时候非常简单
        B:成员变量名称不一样的时候，
            在子类方法中访问变量：
                a:在方法的局部范围找，如果有就是用；
                b:在子类的成员范围找，如果有就是用；
                c:在父类的成员范围找，如果有就是用；
                d:如果找不到，就报错
            就近原则。
            
            java继承中的访问方法的特点：
    A:子类的构造方法执行前都会执行父类无参构造。
    B:为什么呢？
        因为子类继承父类，会继承父类非私有制成员。
        而子类在未初始化的时候，可能会使用父类的数据，如果父类没有初始化，
        子类就不能使用这些数据，所以，在子类初始化之前，一定要先完成父类初始化。

    注意：在子类的构造方法中，默认第一行代码有一条语句：super（）

问题：假如父类中没有无参构造方法，怎么办呢？
    A:在父类中添加一个无参构造方法。(建议使用，其实就是写代码的时候，手动写出无参构造方法)
    B：可以通过super去访问父类的带参构造方法

标题方法的重写

方法重写：子类中出现了与父类相同的方发声明

方法重写的应用：
    当子类需要父类的功能，而功能主体子类又有自己持有内容的时候，就考虑使用方法重写，
    这样既保证父类的功能，还添加了子类的特有的内容。

public class NewPhone extends Phone{
    public void call(String name){
        System.out.println("开启视频功能");
        //System.out.println("给"+name+"打电话");
        super.call(name);
    }
}

@Override 这是注解，这个注解标记一个方法，表明该方法是重写父类的方法

方法重写的注意事项：
    A：父类私有的方法不能重写
    B：子类重写的方法，访问权限不能更低    //private <默认修饰符<public   (比较修饰权限)
        子类重写父类方法时，建议访问权限一模一样。

这里是引用

标题 super 的用法

super和this的用法很像：
this：代表本类对象的引用；
super：代表父类的存储空间（可以理解为代表父类对象的引用）

用法：
    访问成员变量
        this.成员变量
        super.成员变量
    还可以访问构造方法：
        this（...）
        super（...）
    访问成员方法
        this.成员方法（）
        super.成员方法（）

继承中的构造方法

构造方法：用于对象的数据初始化

格式：
        方法名和类名相同；
        没有返回值类型，连void都不能写；
        没有具体的返回值

构造方法的注意事项：
        A:如果我们没有给出构造方法，系统将给出默认的无参构造方法供我们使用
        B:如果我们给出了有参构造方法，系统将不在提供默认的无参构造方法供我们使用。
            这个时候我们想使用无参构造方法，就必须自己提供
            推荐：自己给出无参构造方法
        C:构造方法也是可以重载的。

给成员变量赋值的方法：
        A:通过setXXX（）
        B:通过构造方法

//如何调用构造方法呢？
        //其实通过new关键字就可以
        //格式：类名 对象名=new 构造方法名（...）；
        Student s =new Student();

标准代码写法和测试

标准类的代码写法和测试
类的写法
成员变量
被private修饰
构造方法
无参构造方法
带参构造方法
成员方法
getXxx（）
setXXX（）
给成员变量赋值的方法
无参构造方法+setXXX（）
带参构造方法

测试类的写法

public class StudentTest {
    public static void main(String[] args) {
        //无参构造方法+setXXX（）
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s.getName()+"----"+s.getAge());

        //带参构造方法
        Student s2 =new Student("林青霞",30);
        System.out.println(s2.getName()+"----"+s2.getAge());


    }

}

这里是引用

继承练习感悟

1.使用继承的前提是代码相似度较高；
2.父类需要些，
成员变量
构造方法（有参，无参）
set get方法
3.子类需要
无参构造
有参构造（需要使用super（…）
→用于关联父类的成员变量）
方法

多态

什么是多态
多态：同一个对象，在不同时刻，体现的不同状态。

举例：
猫是猫，猫是动物
水随着温度的变化，可以是固态、液态、气态

java中多态的前提：
        A:有继承关系
        B:有方法重写
        C:有父类引用指向子类的对象。
            Fu f = new Fu();
            Zi z =nwe Zi();

            Fu f = nwe Zi();这就是父类引用指向子类的对象

代码举例

public class DuoTaiDemo {
    public static void main(String[] args) {
        //有父类引用指向子类的对象。
        Animal a = new Cat();

    }
}

多态的访问特点

多态中成员的访问特点
Animal a = new Cat();
左边 | 右边
A:成员变量
编译看左边，执行看左边（意思是成员变量在编译和运行时与左边保持一致）
B:成员方法
编译看左边，执行看右边。（意思是调用成员方法时，编译的时候需要按照左边，执行的是右边）

    为什么成员变量和成员方法的访问不一样？
    
        因为成员方法有重写，而变量没有。

多态的利弊

多态的好处：提高了程序的扩展性
具体体现：定义方法的时候，使用父类型作为参数，将来使用时，使用具体子类型参与操作。
多态的弊端：不能使用子类特有的功能，

public class AnimalOperator {
    /*
    public void useAnimal(Cat c){//相当于Cat c=new Cat（）；
        c.eat();
    }
    public void useAnimal(Dog d){//相当于Dog d= new Dog（）；
        d.eat();
    }
     */
    public void useAnimal(Animal a){//相当于 Animal a = new Xxx（） 多态，编译看左，执行看右
        a.eat();
    }
}

多态转型

/*
    向上转型
            从子到父
            父类引用指向子类对象

    向下转型
            从父到子
            父类引用转为子类对象
 */
public class DuoTaiDemo {
    public static void main(String[] args) {
    //多态形式
    Animal a = new Cat();//向上转型
    a.eat();

   // a.playGame();
        //多态的弊端：无法访问子类特有方法
        //现在我就想使用子类特有方法，怎么办？
        //创建子类对象就可以
        /*
        Cat c = new Cat();
        c.eat();
        c.playGame();
         */
        //现在的代码虽然可以访问子类的特有对象，但是不合理
        //因为我们发现内存中有两个猫类的对象

        //这时候，我们应该想办法把多态的猫对象还原
        //这个时候，就要使用多态中的转型了
        //父类引用转为子类对象
        Cat c = (Cat) a;
        c.playGame();
        c.eat();
}
}