java_13①面向对象-继承

一、继承的概述：

/*
 * 继承：多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），在让多个类去继承这个父类，我们的多个类就可以获取到父类中的成员了。
 * extends
 * 
 */

代码块

public class ExtendsDemo {
	public static void main(String[] args) {
		DotA d = new DotA();
		d.start();
		
		LOL l = new LOL();
		l.start();
	}
}

class Game {
	String name;
	double version;//版本号
	String agent;//代理商
	
	public void start() {
		System.out.println("游戏启动了");
	}
	
	public void stop() {
		System.out.println("游戏关闭了");
	}
}

class DotA extends Game {
	/*String name;
	double version;//版本号
	String agent;//代理商
	
	public void start() {
		System.out.println("游戏启动了");
	}
	
	public void stop() {
		System.out.println("游戏关闭了");
	}*/
}

class LOL extends Game {
	/*String name;
	double version;//版本号
	String agent;//代理商
	
	public void start() {
		System.out.println("游戏启动了");
	}
	
	public void stop() {
		System.out.println("游戏关闭了");
	}*/
	
}

二、继承的特点：

•  	Java语言只支持单一继承，只能继承一个父类（一个儿子只能有一个亲爹）
  

•  	Java语言支持多层继承（一个儿子可以有一个亲爹，还可以有一个亲爷爷）
  

代码块

public class ExtendsDemo2 {
	public static void main(String[] args) {
		LOL l = new LOL();
		l.update();
		l.start();
	}
}

class Game {
	public void start() {
		System.out.println("游戏启动了");
	}
}

class PCGame extends Game {
	public void update() {
		System.out.println("PCGame更新了");
	}
}

class MobileGame extends Game {
	public void update() {
		System.out.println("MobileGame更新了");
	}
}

class LOL extends PCGame {
	
}

三、继承中，成员变量的特点：

		子类只能获取父类非私有成员
		子父类中成员变量的名字不一样直接获取父类的成员变量
		子父类中成员变量名字是一样的获取的是子类的成员变量
 就近原则：

	谁离我近我就用谁

		 如果有局部变量就使用局部变量;
		 如果没有局部变量，有子类的成员变量就使用子类的成员变量;
		如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量;
		 啥都没有，出错了！！！

 super:可以获取父类的成员变量和成员方法,用法和this是相似的

代码块

public class ExtendsDemo3 {
	public static void main(String[] args) {
		Kid3 k = new Kid3();
		k.show();
	}
}

class Dad3 {
	String name = "小明";
}

class Kid3 extends Dad3 {
	String name = "小黄";
	
	public void show() {
		String name = "小华";
		
		System.out.println(super.name);//小明
		System.out.println(this.name);//小黄
		System.out.println(name);//小华
	}
}

四、继承中成员方法的特点：

•  子类中没有这个方法，调用父类的
  

•  子类中重写了这个方法，调用子类的
  

方法的重写：

在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），
当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法

方法的重载：

在一个类中，有多个重名的方法，但是其参数不一样（参数的个数，参数的类型，参数的顺序），和返回值无关

代码块：

public class ExtendsDemo4 {
	public static void main(String[] args) {
		Kid4 k = new Kid4();
		k.eat();
	}
}

class Dad4 {
	public void eat() {
		System.out.println("小酌两口");
		System.out.println("去睡觉了");
	}
}

class Kid4 extends Dad4 {
	public void eat() {
		System.out.println("好好吃饭");
	}
}

五、方法重写

• 方法重写的应用场景：

• 当父类的方法不能完全满足子类使用，这个时候子类重写父类的方法， 并可以在方法中使用关键字super调用父类的方法，这样做即可以保有父类的功能，也可以拥有子类特有的功能

• 方法重写的注意事项：

  不能重写父类私有的方法
  权限必须大于等于父类方法的权限
  

• 注解：@
  代码块：

  public class ExtendsDemo5 {
  public static void main(String[] args) {
  NewPhone np = new NewPhone();
  np.call();
  }
  }

  class Phone {
  void call() {
  System.out.println(“打电话”);
  }
  }

  class NewPhone extends Phone {

  @Override//对重写的说明，代码的规范
  public void call() {
  	System.out.println("录音");
  	//System.out.println("打电话");
  	
  	//super.call();
  }
  

  }

六、继承中构造方法执行顺序：

	在子父类中，创建子类对象，调用子类的构造方法；
	在子类的构造方法的第一行代码，如果没有调用父类
		的构造或者没有调用子类的其他构造，则默认调用父
		类无参构造，肯定先执行父类的构造方法，因为要先
		给父类的成员变量进行初始化，子类可能会使用到。

可以用super
为什么要调用父类构造？

	因为需要给父类的成员变量初始化

肯定会先把父类的构造执行完毕，在去执行子类构造中的其他代码

我是父类无参构造 — 我是子类有参构造 — 我是子类无参构造

public class ExtendsDemo6 {
	public static void main(String[] args) {
		//Die d = new Die();
		Zi6 z = new Zi6();
	}
}

class Die6 {
	public Die6() {
		System.out.println("我是父类无参构造");
	}

public Die6(int num) {
	System.out.println("我是父类有参构造");
}
}

class Zi6 extends Die6 {
	public Zi6() {
		//super(1);调用父类有参构造方法
		//super();调用父类无参构造方法
	
	this(1);//不会再调用父类的无参构造了，调用子类有参构造
	
	System.out.println("我是子类无参构造");
}

public Zi6(int num) {
	//会默认调用父类无参构造
	System.out.println("我是子类有参构造");
}
}

七、this和super的区别

this和super的区别

	this:当前对象的引用
		调用子类的成员变量
		调用子类的成员方法
		在子类的构造方法第一行调用子类其他构造方法
	super:子类对象的父类引用
		调用父类的成员变量
		调用父类的成员方法
		在子类的构造方法第一行调用父类的构造方法

代码块：

public class ExtendsDemo7 {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.function();
	}
}

class Die {
	int num = 10;
	
	public Die() {
		System.out.println("我是父类无参构造");
	}
	
	public Die(int num) {
		System.out.println("我是父类有参构造");
	}
	
	public void method() {
		System.out.println("我是父类的方法");
	}
}


class Zi extends Die {
	//int num = 30;
	
	public Zi() {
		//this(1);//第一行不调用子类其他构造或者是父类构造，默认调用父类无参构造
		super();
		System.out.println("我是子类无参构造");
	}
	
	public Zi(int num) {
		System.out.println("我是子类有参构造");
	}
	
	public void method() {
		System.out.println("我是子类的方法");
	}
	
	public void function() {
		/*this.num = 50;
		System.out.println(num);
		*/
		//输出结果：
			/*
				我是父类无参构造
				我是子类无参构造
				50
			*/
		//this.method();	调用的是子类的方法method（）
			
		//super.num = 40;
		//super.method();
		
		System.out.println(this.num);
	}
}

继承的优缺点：

优：

提高了代码的复用性
提高了代码的可维护性

缺：

类的耦合性增强了
开发的原则：高内聚低耦合

	内聚：就是自己完成某事件的能力
	耦合：类和类之间的关系