学习总结-封装、继承、多态。

Q2：继承

java继承的特征

1：传递性

　　若类C继承类B，类B继承类A（多继承），则类C既有从类B那里继承下来的属性与方法，也有从类A那里继承下来的属性与方法，还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式　　　的，但仍是类C的属性和方法。

2：单根性

　　若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。

 3：子类调用父类成员

　　使用super关键字调用父类成员

　　子类默认会先调用父类的无参构造方法，如果父没有则报错，可以手动指定，但必须在第一行

 举个例子:

package com.zhangyuwei.extend;

public class test1 {
    /*继承*/
    public static void main(String[] args) {
        /**
         * private 私有的，只允许本类访问
         * public 公有的，允许所有类访问
         * protected 受权保护的，只允许子类访问，同包访问
         * default 允许同一个包访问 package，不写访问修饰符
         **/
        Dog dog=new Dog("黄毛","黑色",34.4);
        dog.show();
    }
}
class Animal{
    public String name;
    public String color;
    public Animal(){}
    public Animal(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void show(){
        System.out.println("名称："+name+"，颜色："+color);
    }
}
class Dog extends Animal{
    public double price;
    public Dog(String name,String color,double price){
        super(name,color);
        this.price=price;
    }
    /*重写父类的方法*/
    public void show(){
        super.show();
        System.out.println("价格:"+price);
    }
}

 结果:

Q3:构造方法

构造方法概要

1:构造方法是创建对象时调用的方法，（实例化，new），析构方法

2:构造方法名与类名相同（如Book类的构造方法名称一定Book)

3:构造方法没有返回类型() public Book(){}

4:一个类如果不定义构造方法会默认有一个无参构造方法，如果用户自定义了构造方法则不再默认定义无参构造方法

 默认调用无参构造:

package com.zhangyuwei.extend;

public class test2 {
    public static void main(String[] args) {
        Car car=new Car();
        Car car1=new Car();
    }
}
class Car{
    private int speed;
    public Car(){
        System.out.println("安装轮胎");
        System.out.println("安装方向盘");
        this.speed=230;
    }
}

 结果:

带参数的构造方法

1:构造方法的参数与普通方法相同

2:构造方法允许重载（同名方法不同参数个数或类型）

3：在创建子类时会默认调用父类的构造方法，一般是无参构造

4：使用super可以调用父类指定的构造方法，子类中调用父类的构造方法时必须在第一行

5：使用super可以调用父类中的任意公开成员

package com.zhangyuwei.extend;

public class test3 {
    public static void main(String[] args) {
        Car2 car2=new Car2();//调用空构造
        car2.show();
        Car2 car21=new Car2(120);//调用有参构造
        car21.show();
    }
}
class Car2{
    public int speed;
    public Car2(){this.speed=100;}
    public Car2(int speed){this.speed=speed;}
    public void show(){
        System.out.println("车速为："+this.speed);
    }
}

 结果:

下面这个例子有些好玩。也正好验证了上面一句话(在创建子类时会默认调用父类的构造方法，一般是无参构造)

package com.zhangyuwei.extend;

public class test4 {
    public static void main(String[] args) {
        B b=new B();
        
    }
}
class A{
    public A(){
        System.out.println("A");
    }
}
class B extends A{
    public B(){
        System.out.println("B");
    }
}

 结果: