继承

继承

什么叫继承？

多个类有相同的属性和方法，把共性抽取出来放到另一个类中，然后由这个多个类去继承这个类，这多个类称为子类（派生类），存储共性的类称为父类。继承是描述类与类之间的关系。

继承的好处

1.提高了代码的复用性。2.让类与类之间产生了关系，给第三个特征多态提供了前提。

继承举例

//定义父类Person
public class Person
{
	String name;
	int age;
	char sex;
	//定义eat()
	public void eat()
	{
		System.out.println(name+"大口吃饭");
		}
}
		//定义子类，使用extends关键字来描述子类与父类之间的继承关系
		//定义一个学生类
public class Student extends Person
	{
		String classNum;//定义班级
		//定义study()
		public void Study()
		{
		System.out.println("好好学习");
		}
	}
	//定义一个老师类
public class Teacher extends Person
		{
			String school;//所属学校
			//定义一个manageClass()
			public void manageClass()
			{
			}
		}
		//使用子类的时候，子类会继承父类的非私有成员（成员变量和成员方法）
public class Test
	{
		public static void main(String [] args)
		{
			Student s=new Student();
			Teacher t=new Teacher();
			student.name="张三";
			student.age=18;
			student.sex="男";
			student.eat();
		}
	}	

在java的继承中，只支持单一的继承（一个儿子只能有一个亲爹），不能一个类同时继承多个类，但支持多层继承，即间接继承。

继承中成员变量的特点

1.子类继承父类，可以继承父类中的非私有成员变量
2.如果子类中的成员变量和父类中的成员变量同名，调用的是子类中的成员变量。
在自定义方法中，如果局部变量和子类中的成员变量，父类中的成员变量同名时，方法调用的是局部变量（就近原则），如果想使用子类中的成员变量，用this关键字来标明，如果想使用父类中的成员变量，通过super关键字来标明。

继承中成员方法的特点

1.子类可以继承父类的非私有成员方法
2.当父类的成员方法不满足子类的需求时，子类可以重写父类的成员方法。

什么叫方法重写

在子父类的继承中，子父类的方法名相同，调用的是子类的方法，父类的方法不能在满足子类的需求，子类重写了父类的方法。

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

应用场景：

父类的方法无法在满足子类的需求时

注意事项：

1.方法的重写时要加注解@Override，它能够正确标明是否重写了父类的方法
2.权限问题：子类的权限一定要大于等于父类的权限。

子父类中构造函数的特点

1.子类创建对象的时候会调用父类的构造方法（不是继承构造方法），这是为了给父类的属性进行初始化。
2.在子父类的关系中，创建子类的对象时，子类的构造方法里会默认调用父类的无参构造，通过supper（）（supper()不会写出来）
3.子类的构造方法只能调用一次父类的构造方法，且只能放在有效代码的第一行。

final关键字

final 用来修饰类，方法，变量
1.final修饰的类不能被继承。
2.final修饰的方法不能被重写，但可以被继承。
3.final修饰的变量变为了常量。

练习

练习一、

使用继承机制实现动物世界
创建所有动物的基类Animal类，定义姓名（name）,体重（weight）属性，并创建构造函数初始化属性,定义吃（Eat）的方法，输出“真好吃”。
创建狗类（Dog）,青蛙类（Frog）继承至动物类
为Dog添加咬人的方法，输出“惹我罗，咬死你！”；为Frog添加游泳的方法，输出“洗个澡，真凉快！”。
为狗类和青蛙类定义构造函数初始化属性（要求使用super调用父类的构造函数）
创建一只狗对象，调用其方法；创建一只青蛙，调用其方法

练习二、

— 创建一个动物类:
Animal:字段:name,sex访问修饰符均为public
Amimal:构造函数:无参，带两个参的分别为name和sex赋值
— 创建一个鸡类Ji继承于Animal
Ji:私有字段:chiBang,用属性封装
Ji:构造函数:带三个参的分别为name和sex和chiBang赋值,name和sex在父类赋值
Ji:toString()方法，用来作自我介绍，打印:我是XXX,我是XXX,我有XXX
— 创建一个狗类Dog继承于Animal
Dog:私有字段:weiBa,用属性封装
Dog:构造函数:带三个参数分别为name,sex,weiBa赋值,name和sex在父类赋值
Dog: toString()方法，用来作自我介绍，打印:我是XXX,我是XXX,我有XXX
— 在测试类Main方法内:
定义二个鸡对象:
花花,母,一对金黄色的翅膀
草草,公,一对银黄色的翅膀
定义二个狗对象:
小白,公,一条金白色的尾巴
小黄,母,一条银白色的尾巴
生成4个对象，分别调用相应的方法。

练习1

//父类
public class Animal {
    //属性：
    /*姓名  name
    体重  weight
    * */
    String name;
    double weight;
    //构造函数
    //无参构造
    public Animal()
    {
        System.out.println("父类的构造函数执行了");
    }
    //有参构造
    public Animal(String name,double weight)
    {
        this.name=name;
        this.weight=weight;
    }
    //定义方法eat()
    public void eat()
    {
        System.out.println("真好吃");
    }
}

public class Dog extends Animal{
    //定义无参构造函数
    public Dog()
    {
        super();
    }
    //添加方法bite()

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

public class Frog extends Animal{
    //定义无参构造函数
    public Frog()
    {
        super();
    }
    //添加游泳的方法
    public void swimming()
    {
        System.out.println("洗个澡，真凉快");
    }
}

public class AnimalTest {
    public static void main(String[] args)
    {
        Dog d=new Dog();
        Frog f=new Frog();
           d.bite();
           f.swimming();
    }
}

结果

练习2

public class Animal {
    public String name;
    public char sex;
    //无参构造
    public Animal()
    {

        System.out.println("这是Animal的无参构造");
    }
    public Animal(String name,char sex)
    {
        this.name=name;
        this.sex=sex;
    }
}

public class Dog extends Animal{
    private String weiBa;
    public Dog(String name,char sex,String weiBa)
    {
        super(name, sex);
        this.weiBa=weiBa;
    }
    @Override
    public String toString()
    {
        return "我是"+name+"我是"+sex+"我有"+weiBa;
    }
}

public class Ji extends Animal{
    private String chiBang;
    public Ji(String name,char sex,String chiBang)
    {
        super(name, sex);
        this.chiBang=chiBang;
    }

  

    @Override
    public String toString() {
        return "我是"+name+"我是"+sex+"我有"+chiBang;
    }
}

public class AnimalTest {
    public static void main(String [] args)
    {
        Ji j1=new Ji("花花",'母',"一队金黄色的翅膀");
        Ji j2=new Ji("草草",'公',"一队银黄色的翅膀");
        Dog d1=new Dog("小白",'公',"一条金白色的尾巴");
        Dog d2=new Dog("小黄",'公',"一条银白色的尾巴");
        System.out.println(j1);
        System.out.println(j2);
        System.out.println(d1);
        System.out.println(d2);
    }
}

结果: