Java学习的第十三天（JavaSE精英篇03_继承）

一、面向对象的三大特性：封装、继承、多态

二、什么是封装

封装体现在很多方面，提高了代码的复用性和安全性
	1.类封装了属性和方法
	2.先属性私有化，然后通过setXxx()设置属性和getXxx()获取属性
	3.方法同样封装了一些功能

三、什么是继承？需要用到extends关键字

定义：多个类拥有相同的属性和方法，把共性抽取出来放到另一个类中，然后由这多个类去继承这个类
多个类称之为子类（派生类）
存储共性的类称之为父类（基类）

package com.bianyiit.jicheng;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
/*java中继承的特点
1.java只支持单一继承（一个儿子只能有一个亲爹，但是一个亲爹可以有一个亲爷爷）
2.java支持多层继承（允许爷爹儿三代），而不支持多个继承（一个儿子两亲爹是不允许的）*/
public class GameTest {
    public static void main(String[] args) {
        Game g1 = new Game();
        g1.start();
        g1.end();
    }
}
class PCGame{
    String name="111";
    public void start(){
        System.out.println("PC游戏开始了");
    }
}
class MobileGame extends PCGame{
    String name="222";
    public void end(){
        System.out.println("mobile游戏结束了");
    }
}
class Game extends MobileGame{
    
}

四、Java中继承的特点

1.Java只支持单一继承（一个儿子只能有一个亲爹，一个亲爹可以有一个亲爷爷）
2.Java不支持多继承，支持多层继承

五、继承中成员变量的特点

1.子类继承了父类，可以继承父类中的非私有成员变量
2.如果子类中的成员变量和父类中的成员变量同名，调用的是子类的成员变量（因为子类和父类都有100元，先把自己的100元用了，然后再用父类的）

六、super关键字（父类的引用）

定义：通过super关键字可以使用父类的非私有成员（不代表父类的对象，相当于一个指针，指向了父类）

如果父类中的成员变量，子类中的成员变量和局部变量同名，使用的是局部变量（就近原则）
如果想使用子类中的成员变量，通过this关键字标识
如果想使用父类中的成员变量，通过super关键字标识

七、方法的重载和重写

重载：在同一个类中，方法名相同，参数列表（参数的个数，参数的类型，参数的顺序）不同，与返回值无关
重写：在子父类关系中，子父类的方法名相同，调用的是子类的方法，如果父类的方法不能满足子类的需求，所以子类重写了父类的方法满足自己的需求

八、继承关系中的方法的特点

1.子类可以继承父类的非私有成员方法
2.当父类的成员方法不满足子类的需求时，应该自己写一个一样的方法，但方法里面的实现功能不同

九、方法重写应用场景和注意事项

应用场景：父类的方法无法满足子类的需求时
注意事项：
	1.方法重写时需要加注解@override（方法的覆盖，能够标明方法是否重写了父类的方法，还是自己自定义的方法）
	2.权限问题，子类的权限大于或等于父类的权限

十、继承中的构造方法

注意：子父类构造方法使用的不是继承，是调用

private String weiba;

    public Dog() {
        super();//默认在此调用的父类的无参构造
    }

    public Dog(String name,char sex,String weiba) {
        super(name,sex);  //调用父类的有参构造
        this.weiba = weiba;
    }
总结：
	1.构造方法不是被子类继承过去的，而是存在继承关系的时候，创建子类对象时会去调用父类的构造方法，为了给父类的属性初始化用的，因为子类要继承父类的成员
	2.在子父类关系中创建了子类对象时，子类的构造方法里面会默认调用父类的无参构造方法，通过super();进行调用--而且需要放在有效代码的第一行
	3.子类的构造方法只能调用一次父类的构造方法

十一、子类创建对象的时候会调用父类的构造方法，目的是什么？？

目的是为了给父类的属性初始化用的

十二、final关键字（用来修饰类/成员/变量）

格式：final static USER_NAME="张三" 常量的书写用大写字母表示，多个单词中间使用_隔开

修饰的是类时，不能被继承
修饰的是成员时，不能被重写
修饰的是变量时，变为常量
final修饰的方法可以被继承，但是不能被重写

常量一般结合static使用，可以直接通过类名直接调用，而常量是可以继承的

十三、继承的优缺点

优点：

	1.提高了代码的复用性
	2.提高了代码的可维护性（只需要在父类中进行维护就行了，子类可以直接继承父类的维护的方法，故可以具备维护的功能）

缺点：低内聚高耦合（这是由Java的特性决定的，无法避免）

	1.内聚：单个类独立完成事情的能力
	2.耦合：类与类之间的联系

做开发的原则：高内聚低耦合

十四、代码块

//CodeKuai.java
package com.bianyiit.cast;

public class CodeKuai {
    String name;
    int age;
    //构造代码块
    {
        run();
    }
    //静态代码块
    static {
        System.out.println("这是静态代码块");
    }
    public CodeKuai() {
    }

    public CodeKuai(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void run(){
        System.out.println("这是构造代码块");
    }
    public void eat(){
        //局部代码块
        {
            String name = "这是局部代码块";
            System.out.println(name);
        }
    }
    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;
    }
}
//CodeKuaiTest.java
package com.bianyiit.cast;

public class CodeKuaiTest {
    public static void main(String[] args) {
        CodeKuai a = new CodeKuai();
        a.eat();
    }
}

课后作业

//父类Animal
package com.bianyiit.homework;

public class Animal {
    public String name;
    public int weight;
    final static String WU_ZHONG="动物";

    public Animal() {
        System.out.println("这是Animal的无参构造！");
    }

    public Animal(String name, int weight) {
        this.name = name;
        this.weight = weight;
        System.out.println("这是Animal的有参构造！");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    final public void eat(){
        System.out.println("真好吃！！");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", weight=" + weight +
                '}';
    }
}
//子类Dog
package com.bianyiit.homework;

public class Dog extends Animal {
    public Dog() {
        super();
    }

    public Dog(String name, int weight) {
        super(name, weight);
    }

    public void bark(){
        System.out.println("惹我咯，咬死你！！");
    }

}
//子类的测试类DogTest
package com.bianyiit.homework;

public class DogTest {
    public static void main(String[] args) {
        Dog dog1 = new Dog();  //无参构造
        System.out.println(dog1);  //直接通过dog1调用父类的toString方法
        System.out.println(Dog.WU_ZHONG);  //通过类名调用final修饰的变量
        dog1.eat();  //调用父类final修饰的Animal中自定义的方法eat();
        dog1.bark(); //调用子类自定义的方法bark();
        System.out.println();
        Dog dog2 = new Dog("拉布拉多",20);  //继承之后的有参构造方法
        System.out.println(dog2);
        System.out.println(Dog.WU_ZHONG);  //通过类名调用final修饰的变量
        dog1.eat();  //调用父类final修饰的Animal中自定义的方法eat();
        dog2.bark();
    }
}
//输出结果：
	这是Animal的无参构造！
	Animal{name='null', weight=0}
	动物
	真好吃！！
	惹我咯，咬死你！！
	
	这是Animal的有参构造！
	Animal{name='拉布拉多', weight=20}
	动物
	真好吃！！
	惹我咯，咬死你！！

//父类Animal
package com.bianyiit.homework2;

public class Animal {
    public String name;
    public char sex;

    public Animal() {
    }

    public Animal(String name, char sex) {
        this.name = name;
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                '}';
    }
}
//子类Dog
package com.bianyiit.homework2;

public class Dog extends Animal{
    private String weiba;

    public Dog() {
        super();
    }

    public Dog(String name,char sex,String weiba) {
        super(name,sex);
        this.weiba = weiba;
    }
    public String toString(){
        return "我是"+this.name+",我是"+this.name+",我有"+this.weiba+"的尾巴";
    }
}
//子类测试类DogTest
package com.bianyiit.homework2;

public class DogTest {
    public static void main(String[] args) {
        Dog dog1 = new Dog("小白", '公', "金白色");
        System.out.println(dog1.toString());
        Dog dog2 = new Dog("小黄", '母', "银白色");
        System.out.println(dog2.toString());
    }
}
//输出结果：
	我是小白,我是小白,我有金白色的尾巴
	我是小黄,我是小黄,我有银白色的尾巴