JAVA语言基础-面向对象(继承）

2019独角兽企业重金招聘Python工程师标准>>>

继承(extends)

• 让类与类之间产生关系,子父类关系

class Demo1_Extends {
	public static void main(String[] args) {
		Cat c = new Cat();
		c.color = "花";
		c.leg = 4;
		c.eat();
		c.sleep();

		System.out.println(c.leg  + "..." + c.color);
	}
}
/*
* A:继承(extends)
	* 让类与类之间产生关系,子父类关系 
* B:继承案例演示：
	* 动物类,猫类,狗类
	* 定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
* C:案例演示
	* 使用继承前
* D:案例演示
	* 使用继承后
*/
class Animal {
	String color;					//动物的颜色
	int leg;						//动物腿的个数

	public void eat() {				//吃饭的功能
		System.out.println("吃饭");
	}

	public void sleep() {			//睡觉的功能
		System.out.println("睡觉");
	}
}

class Cat extends Animal {
	
}

class Dog extends Animal {
	
}

/*
extends是继承的意思
Animal是父类
Cat和Dog都是子类
*/

继承的好处和弊端)(掌握)

• A:继承的好处
  • a:提高了代码的复用性
  • b:提高了代码的维护性
  • c:让类与类之间产生了关系，是多态的前提

• B:继承的弊端

  • 类的耦合性增强了。

  • 开发的原则：高内聚，低耦合。

  • 耦合：类与类的关系
  • 内聚：就是自己完成某件事情的能力

面向对象(Java中类的继承特点)(掌握)

• A:Java中类的继承特点
  • a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
    • 有些语言是支持多继承，格式：extends 类1,类2,...
  • b:Java支持多层继承(继承体系)
• B:案例演示
  • Java中类的继承特点
    • 如果想用这个体系的所有功能用最底层的类创建对象
    • 如果想看这个体系的共性功能,看最顶层的类         

class Demo2_Extends {
	public static void main(String[] args) {
		DemoC d = new DemoC();
		d.show();
	}
}
/*
* A:Java中类的继承特点
	* a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
		* 有些语言是支持多继承，格式：extends 类1,类2,...
	* b:Java支持多层继承(继承体系)
* B:案例演示
	* Java中类的继承特点
		* 如果想用这个体系的所有功能用最底层的类创建对象
		* 如果想看这个体系的共性功能,看最顶层的类 
*/
class DemoA {
	public void show() {
		System.out.println("DemoA");
	}
}

class DemoB extends DemoA {
	public void method() {
		System.out.println("DemoB");
	}
}

class DemoC extends DemoB {
	public void print() {
		System.out.println("DemoC");
	}
}

面向对象(继承的注意事项和什么时候使用继承)(掌握)

• A:继承的注意事项
  • a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
  • b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
  • c:不要为了部分功能而去继承
  • 项目经理 姓名 工号 工资 奖金
  • 程序员 姓名 工号 工资

• B:什么时候使用继承

  • 继承其实体现的是一种关系："is a"。 Person Student Teacher 水果 苹果 香蕉 橘子

  采用假设法。 如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

class Demo3_Extends {
	public static void main(String[] args) {
		Son s = new Son();
		s.show();
	}
}
/*
* A:继承的注意事项
	* a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
	* b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
	* c:不要为了部分功能而去继承
	* 项目经理 姓名 工号 工资 奖金
	* 程序员	姓名 工号 工资
*/

class Father {
	private String name;
	private void show() {
		System.out.println("Hello World!");
	}
}

class Son extends Father {
}

面向对象(继承中成员变量的关系)(掌握)

• A:案例演示
  • a:不同名的变量
  • b:同名的变量

class Demo4_Extends {
	public static void main(String[] args) {
		Son s = new Son();
		s.print();
	}
}
/*
* A:案例演示
	* a:不同名的变量
	* b:同名的变量
		子父类出现同名的变量只是在讲课中举例子有,在开发中是不会出现这种情况的
		子类继承父类就是为了使用父类的成员,那么如果定义了同名的成员变量没有意义了
*/

class Father {
	int num1 = 10;
	int num2 = 30;
}

class Son extends Father {
	int num2 = 20;

	public void print() {
		System.out.println(this.num1);				//this既可以调用本类的,也可以调用父类的(本类没有的情况下)
		System.out.println(this.num2);				//就近原则,子类有就不用父类的了
		System.out.println(super.num2);
	}
}

(继承中构造方法的关系)(掌握)

• A:案例演示
  • 子类中所有的构造方法默认都会访问父类中空参数的构造方法         

• B:为什么呢?

  • 因为子类会继承父类中的数据，可能还会使用父类的数据。

  • 所以，子类初始化之前，一定要先完成父类数据的初始化。

  • 其实：

    • 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。

class Demo5_Extends {
	public static void main(String[] args) {
		Son s = new Son();
	}
}
/*
* A:案例演示
	* 子类中所有的构造方法默认都会访问父类中空参数的构造方法
* B:为什么呢?
	* 因为子类会继承父类中的数据，可能还会使用父类的数据。
	* 所以，子类初始化之前，一定要先完成父类数据的初始化。
	
	* 其实：
		* 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。
*/

class Father extends Object {
	public Father() {
		super();
		System.out.println("Father 的构造方法");
	}
}

class Son extends Father {
	public Son() {
		super();							//这是一条语句,如果不写,系统会默认加上,用来访问父类中的空参构造
		System.out.println("Son 的构造方法");
	}
}

08.10_面向对象(继承中构造方法的注意事项)(掌握)

• A:案例演示
  • 父类没有无参构造方法,子类怎么办?
  • super解决
  • this解决           

class Demo6_Extends {
	public static void main(String[] args) {
		Son s1 = new Son();
		System.out.println(s1.getName() + "..." + s1.getAge());
		System.out.println("--------------------");
		Son s2 = new Son("张三",23);
		System.out.println(s2.getName() + "..." + s2.getAge());
	}
}
/*
* A:案例演示
	* 父类没有无参构造方法,子类怎么办?
	* super解决
	* this解决
* B:注意事项
	* super(…)或者this(….)必须出现在构造方法的第一条语句上
*/
class Father {
	private String name;			//姓名
	private int age;				//年龄

	public Father() {				//空参构造
		System.out.println("Father 空参构造");
	}

	public Father(String name,int age) {	//有参构造
		this.name = name;
		this.age = age;
		System.out.println("Father 有参构造");
	}

	public void setName(String name) {	//设置姓名
		this.name = name;
	}

	public String getName() {			//获取姓名
		return name;
	}

	public void setAge(int age) {		//设置年龄
		this.age = age;
	}

	public int getAge() {				//获取年龄
		return age;
	}
}

class Son extends Father {
	public Son() {						//空参构造
		this("王五",25);				//本类中的构造方法
		//super("李四",24);				//调用父类中的构造方法
		
		System.out.println("Son 空参构造");
	}

	public Son(String name,int age) {	//有参构造
		super(name,age);
		System.out.println("Son 有参构造");
	}
}

• B:注意事项
  • super(…)或者this(….)必须出现在构造方法的第一条语句上

08.11_面向对象(继承中的面试题)(掌握)

• A:案例演示

• class Fu{
  	public int num = 10;
  	public Fu(){
  		System.out.println("fu");
  	}
  }
  class Zi extends Fu{
  	public int num = 20;
  	public Zi(){
  		//super();
  		System.out.println("zi");
  	}
  	public void show(){
  		int num = 30;
  		System.out.println(num);
  		System.out.println(this.num);  //调用本类的成员变量20
  		System.out.println(super.num); //调用父类的成员变量10
  	}
  }
  class Test1_Extends {
  	public static void main(String[] args) {
  		Zi z = new Zi();
  		z.show();
  	}
  }
  

  class Test2_Extends {
  	public static void main(String[] args) {
  		Zi z = new Zi();
  	}
  	/*
  	1,jvm调用了main方法,main进栈
  	2,遇到Zi z = new Zi();会先将Fu.class和Zi.class分别加载进内存,再创建对象,当Fu.class加载进内存
  	父类的静态代码块会随着Fu.class一起加载,当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载
  	第一个输出,静态代码块Fu,第二个输出静态代码块Zi
  	3,走Zi类的构造方法,因为java中是分层初始化的,先初始化父类,再初始化子类,所以先走的父类构造,但是在执行
  	父类构造时,发现父类有构造代码块,构造代码块是优先于构造方法执行的所以
  	第三个输出构造代码块Fu,第四个输出构造方法Fu
  	4,Fu类初始化结束,子类初始化,第五个输出的是构造代码块Zi,构造方法Zi
  	*/
  }
  class Fu {
  	static {
  		System.out.println("静态代码块Fu");
  	}
  
  	{
  		System.out.println("构造代码块Fu");
  	}
  
  	public Fu() {
  		System.out.println("构造方法Fu");
  	}
  }
  
  class Zi extends Fu {
  	static {
  		System.out.println("静态代码块Zi");
  	}
  
  	{
  		System.out.println("构造代码块Zi");
  	}
  
  	public Zi() {
  		System.out.println("构造方法Zi");
  	}
  }
  
  

   

• 看程序写结果1
  class Fu{
      public int num = 10;
      public Fu(){
          System.out.println("fu");
      }
  }
  class Zi extends Fu{
      public int num = 20;
      public Zi(){
          System.out.println("zi");
      }
      public void show(){
          int num = 30;
          System.out.println(num);
          System.out.println(this.num); //调用本类成员变量20
          System.out.println(super.num);//调用父类成员变量10
      }
  }
  class Test1_Extends {
      public static void main(String[] args) {
          Zi z = new Zi();
          z.show();
      }
  }
  
  看程序写结果2
  class Fu {
      static {
          System.out.println("静态代码块Fu");
      }
  
      {
          System.out.println("构造代码块Fu");
      }
  
      public Fu() {
          System.out.println("构造方法Fu");
      }
  }
  
  class Zi extends Fu {
      static {
          System.out.println("静态代码块Zi");
      }
  
      {
          System.out.println("构造代码块Zi");
      }
  
      public Zi() {
          System.out.println("构造方法Zi");
      }
  }
  
  Zi z = new Zi(); 请执行结果。
  

08.12_面向对象(继承中成员方法关系)(掌握)

• A:案例演示
  • a:不同名的方法
  • b:同名的方法   

class Demo7_Extends {
	public static void main(String[] args) {
		Son s = new Son();
		s.print();
		s.method();
	}
}
/*
* a:不同名的方法
* b:同名的方法
*/

class Father {
	public void print() {
		System.out.println("Fu print");
	}
}

class Son extends Father {
	public void method() {
		System.out.println("Zi Method");
	}

	public void print() {
		super.print();							//super可以调用父类的成员方法
		System.out.println("Zi print");
	}
}

 

转载于:https://my.oschina.net/u/3668429/blog/1928056