面向对象.继承

//父类
public class Animal {
	String name ;
	String  gender ;
	int age ;
	//1)在父类中创建构造函数,在子类中直接调用,可以简化子类构造函数的代码量
	//2)构造函数的作用是连接实参 形参 以及成员变量属性	
	//3)连接原理是 对象调 方法属性地址,放法连接代码区的代码地址,对象连接常量区的地址
	public Animal(String name, String gender, int age) {
		super();
		this.name = name;
		this.gender = gender;
		this.age = age;
		//2)在用new创建对象时程序先执行父类的构造函数,因此在
		System.out.println("调用有参构造函数");
	}
	public Animal() {
		super();
		System.out.println("调用无参构造函数");
	}
	void eat() {
		System.out.println("动物吃东西");
	}
	
}
//子类Dog
public class Dog extends Animal{
	String color;

	public Dog(String name, String gender, int age, String color) {
		super(name, gender, age);
		this.color = color;
	}

	public Dog(String name, String gender, int age) {
		super(name, gender, age);
	}
	public void eat() {
		//此处this指代Dog类的成员变量属性名
		System.out.println(this.name+"吃狗粮");
		//用super调用父类的名字
		System.out.println(super.name+"吃狗粮");
	}
	
}
//子类Person
public class Person extends Animal {
	String nation ;
	String name ;
	public Person(String name, String gender, int age, String nation) {
		//1)本来这里是this.name = name,这样实参 成员变量属性 形参就建立了联系,但既然有继承关系就可以在父类构造函数中将父类的形参与成员变量产生联系,然后用super调取
		//如此子类中的形参 父类中的形参 实参建立联系,故子类中的代码即可简化为两行,本来
		//2)super用于调用父类有参构造函数目的是为了简化子类构造函数的代码量且调构造函数时只能放在第一行
		//3)且super()的形参列表是父类中的共有属性
		super(name, gender, age);
		this.nation = nation;
		//this.name = name;
		//this.gender = gender ;
		//this.age = age ;
	}
	public Person() {
		//super调无参
		super();
	}
	public void eat() {
		System.out.println(this.name+"吃人粮");
		//4)super调用父类的name
		System.out.println(super.name+"吃人粮");
		//5)super调方法,调完之后子类将拥有自己和父类的共计两种方法
		super.eat();
	}
	
}
//测试类
public class Test {
	
	public static void main(String[] args) {
		Person p1 = new Person("张三","男", 15,"中国");
		Dog d1 = new Dog("旺财", "公", 3);
		System.out.println(p1.name);
		p1.eat();
		//d1.eat();
		//1)object是所有类的子类,因此所有类继承object,因此任何子类都可以调用object中的方法
		//2)按住Ctrl光标放在方法名上直接进入object原码中说明该方法源于object
		//3)如果一个类没有写明继承于谁则默认继承与object
		Demo01 demo01 = new Demo01();
		demo01.getClass();
	}		
}
//无构造函数类Demo01
public class Demo01 {

}

 总代码展示如上:

1.通过Animal Peson Dog之间的继承关系案例理解继承

//1)在代码执行的时候先执行构造函数,此时实参就被传输进去
    Person p1 = new Person("张三","男", 15,"中国");
		Dog d1 = new Dog("旺财", "公", 3);
//2)因此new两次对象,也就意味着父类的构造函数执行了两次执行结果如下:
    调用有参构造函数
    调用有参构造函数

总结:1)首先在父类中创建父类的构造函数并在子类的构造函数中用super调用父类的构造函数可使得子类构造函数的代码量大大简化(一行代替三四行)此时子类已经继承父类的构造函数.

2)由于在1)中子类构造函数继承了父类的构造函数因此在new创建对象的时候就直接调用了父类的构造函数,因此new了两次对象后父类的构造函数被运行了两次.

3)当代码执行构造函数时,实参也就被传输进去,并与形参以及成员变量属性产生联系,联系原理是对象与堆中属性和方法所形成的区域的地址产生联系,然后通过对象名.属性或对象名.方法 实现堆属性和方法的调用,而堆中属性和方法的地址与分别与代码区的常量地址和存放类中所有方法的方法区地址产生联系,由此对象 实参 形参 成员变量之间建立联系

public void eat() {
		//此处this指代Dog类的成员变量属性名
		System.out.println(this.name+"吃狗粮");
		//用super调用父类的名字
		System.out.println(super.name+"吃狗粮");
	}
//super和this的区别和super调属性和方法
public void eat() {
		System.out.println(this.name+"吃人粮");
		//4)super调用父类的name
		System.out.println(super.name+"吃人粮");
		//5)super调方法,调完之后子类将拥有自己和父类的共计两种方法
		super.eat();
	}
//super调构造函数
public Dog(String name, String gender, int age, String color) {
		super(name, gender, age);
		this.color = color;
	}

总结:1)在同一个类中,this用于区分局部变量和成员变量属性即this.name就指代成员变量属性

2)super的用法:用于调父类属性方法 和构造函数

        2.1)super用于区分父类的属性super.name  和子类的属性名

        2.2)super调父类方法super.eat()

        2.3)super调父类构造函数super(name,gender,age) 形参为父类的形参中的变量名,且super必须放在第一行   

//object为所有类的父类,且object中含有所有类中所有的方法以及构造函数
//Demo01中无构造函数
public class Demo01 {

}
//demo01中无构造函数,但仍然可以创建对象是因为其继承了object而object中有构造函数,因此demo01继承了object的构造函数
Demo01 demo01 = new Demo01();
//Demo01中无方法,但依然可以调用方法getclass是因为Demo01继承了object的所有方法
		demo01.getClass();

总结:1)object为所有类的父类,因此 Demo01在没有构造函数的情况下仍然能够创建对象是因为继承了object的构造函数,

2)demo01调用的是object中的方法

3)按住Ctrl光标放在方法上即可进入getclass所在的object父类