《java入门第一季》之面向对象（继承总结）

继承已经全部写完了，接下来通过几个案例对继承问题做一个总结：

/*
	看程序写结果：
		A:成员变量	就近原则
		B:this和super的问题
			this访问本类的成员
			super访问父类的成员
		C:子类构造方法执行前（默认）先执行父类的无参构造方法
		D:一个类的初始化过程
			成员变量进行初始化
				默认初始化
				显示初始化
				构造方法初始化
				
	结果：
		fu
		zi
		30
		20
		10
*/
class Fu{
	public int num = 10;
	public Fu(){
		System.out.println("fu");
	}
}
class Zi extends Fu{
	public int num = 20;
	public Zi(){
		//super();此时默认含有super();调用父类的无参构造方法。这里其实先进行分层初始化
		System.out.println("zi");
	}
	public void show(){
		int num = 30;
		System.out.println(num); //30
		System.out.println(this.num); //20
		System.out.println(super.num); //10
	}
}
class ExtendsTest {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();
	}
}

/*
	学生案例和老师案例讲解
	
	学生：
		成员变量；姓名，年龄
		构造方法：无参，带参
		成员方法：getXxx()/setXxx()
	老师：
		成员变量；姓名，年龄
		构造方法：无参，带参
		成员方法：getXxx()/setXxx()
		
	看上面两个类的成员，发现了很多相同的东西，所以我们就考虑抽取一个共性的类：
	人：
		成员变量；姓名，年龄
		构造方法：无参，带参
		成员方法：getXxx()/setXxx()
		
		学生 继承 人
		老师 继承 人
*/
//定义一个人类
class Person{
	//姓名
	private String name;
	//年龄
	private int age;
	public Person(){
	}
	public Person(String name,int age){//杨道龙，24
		this.name = name;
		this.age = age;
	}
	
	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;
	}
}
class Student extends Person{
		public Student(){//无参构造
		}
		public Student(String name,int age){//必须有参构造//杨道龙，24
		    /*this.name = name;
			this.age = age;*///错误，私有的成员变量无法访问
			super(name,age);//去找父类中的有参构造，并把值传递过去
		}

	}
class Teacher extends Person{
		public Teacher(){
		}
		public Teacher(String name,int age){
			super(name,age);
		}
	}

class ExtendsTest4{
	public static void main(String[] args){
		//方式一
		Student s1 = new Student();
		s1.setName("杨道龙");//对象调用方法。先在子类中找，找不到再去父类中找
		s1.setAge(24);//对象调用方法。先在子类中找，找不到再去父类中找。其实是赋值给了子类继承后的方法中了。
		System.out.println(s1.getName()+"----"+s1.getAge());
		//方式二
		Student s2 = new Student("杨道龙",24);
		System.out.println(s2.getName()+"----"+s2.getAge());//对象调用方法，先在子类中找，找不到，再去父类中找。继承关系
		
		//创建老师测试对象
		//方式一：
		Teacher t1 = new Teacher();
		t1.setName("孙晓晓");
		t1.setAge(23);
		System.out.println(t1.getName()+"----"+t1.getAge());
		//方式二
		Teacher t2 = new Teacher("孙晓晓",23);
		System.out.println(t2.getName()+"----"+t2.getAge());
		
	}
}

/*
	猫狗案例讲解
	
	先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。
	
	猫：
		成员变量：姓名，年龄，颜色
		构造方法：无参，带参
		成员方法：
			getXxx()/setXxx()
			eat()
			palyGame()
	狗：
		成员变量：姓名，年龄，颜色
		构造方法：无参，带参
		成员方法：
			getXxx()/setXxx()
			eat()
			lookDoor()
			
	共性：
		成员变量：姓名，年龄，颜色
		构造方法：无参，带参
		成员方法：
			getXxx()/setXxx()
			eat()
			
	把共性定义到一个类中，这个类的名字叫：动物。
	动物类：
		成员变量：姓名，年龄，颜色
		构造方法：无参，带参
		成员方法：
			getXxx()/setXxx()
			eat()
			
		猫：	
			构造方法：无参，带参
			成员方法：palyGame()
		狗：
			构造方法：无参，带参
			成员方法：lookDoor()
*/
//定义动物类
class Animal {
	//姓名
	private String name;
	//年龄
	private int age;
	//颜色
	private String color;
	
	public Animal() {}
	
	public Animal(String name,int age,String color) {
		this.name = name;
		this.age = age;
		this.color = color;
	}
	
	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;
	}
	
	public String getColor() {
		return color;
	}
	
	public void setColor(String color) {
		this.color = color;
	}
	
	public void eat() {
		System.out.println("不要睡了,该吃饭了");
	}
}

//定义猫类
class Cat extends Animal {
	public Cat() {}
	
	public Cat(String name,int age,String color) {
		super(name,age,color);
	}
	
	public void playGame() {//猫特有的方法，动作
		System.out.println("猫玩英雄联盟");
	}
}

//定义狗类
class Dog extends Animal {
	public Dog() {}
	
	public Dog(String name,int age,String color) {
		super(name,age,color);
	}
	
	public void lookDoor() {
		System.out.println("狗看家");
	}
}

//测试类
class ExtendsTest5 {
	public static void main(String[] args) {
		//测试猫
		//方式1
		Cat c1 = new Cat();
		c1.setName("Tom");
		c1.setAge(3);
		c1.setColor("白色");
		System.out.println("猫的名字是："+c1.getName()+";年龄是："+c1.getAge()+";颜色是："+c1.getColor());
		c1.eat();
		c1.playGame();
		System.out.println("---------------");
		
		//方式2
		Cat c2 = new Cat("杰瑞",5,"土豪金");
		System.out.println("猫的名字是："+c2.getName()+";年龄是："+c2.getAge()+";颜色是："+c2.getColor());
		c2.eat();
		c2.playGame();
		
		//作业：测试狗
		//方式一
		Dog d1 = new Dog();
		d1.setName("皮毛");
		d1.setAge(5);
		d1.setColor("黑色");
		System.out.println("狗的名字是"+d1.getName()+",他今年"+d1.getAge()+"岁了，它的颜色是："+d1.getColor());
		d1.eat();
		d1.lookDoor();
		//方式二
		Dog d2 = new Dog("皮毛2",4,"白色");
		System.out.println("狗的名字是"+d2.getName()+",他今年"+d2.getAge()+"岁了，它的颜色是："+d2.getColor());
		d2.eat();
		d2.lookDoor();
	}
}

《java入门第一季》之面向对象（继承总结）

相关推荐