Java-继承和抽象类

继承

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

package com.it01;
/*
 * 	继承：多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），让多个类去继承就可以获取父类中的成员了。
 */
public class ExtendsDemo {
	
	public static void main(String[] args) {
		DotA d= new DotA();
		d.start();
		d.stop();
		
		LOL l = new LOL();
		l.start();
		l.stop();
	}

}

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中只能单继承，即一个类只能有一个父类
• Java中支持多层继承

package com.it01;
/*
 * 	Java的继承特点
 * 		Java中只能单继承，即一个类只能有一个父类
 * 		Java中支持多层继承
 */
public class ExtendsDemo2 {
	public static void main(String[] args) {
		LOL1 l = new LOL1();
		l.update();
		l.start();
		l.stop();
	}

}

class Game1{
	String name;
	double version;
	String agent;
	
	public void start() {
		System.out.println("游戏开始");
	}
	public void stop() {
		System.out.println("游戏关闭");
	}
}

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

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

class LOL1 extends PCGame{
	
}
//Java中只能单继承，即一个类只能有一个父类
/*
class LOL extends MobileGame{
	
}
*/

package com.it01;
/*
 * 	子类只能获取父类非私有成员
 * 	就近原则：在子父类中成员变量名字不一样，则寻找父类中的成员变量
 * 			成员变量名字一样时，获取子类中的成员变量
 * 
 * 	super关键字：可以获取父类的成员变量和成员方法，用法和this相同
 */
public class ExtendsDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Kid k = new Kid();
		k.show();
	}

}
 class Dad{
	 String name= "小刘";
 }
 
 class Kid extends Dad{
	 String name = "小小六";
	 public void show() {
		 String name= "大周";
		 System.out.println(super.name);//小刘
		 System.out.println(this.name);//小小六
		 System.out.println(name);//大周
	 }
 }

继承中成员方法的特点

• 方法的重写：在子类的方法中，子类的方法和父类的方法完全一样，子类重写了父类的方法（覆盖），使用子类对象，调用子类中的方法，调用父类中的方法时，使用super关键字

package com.it01;
public class ExtendsDemo4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Kid1 k = new Kid1();
		k.eat();
	}

}

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

class Kid1 extends Dad1{
	public void eat() {
		 System.out.println("吃饭");
		 System.out.println("运动");
	 }
}

方法重写

• 当父类中的方法不能满足子类，这个时候子类重写父类的方法
  并可以在方法中使用super调用父类的方法

package com.it01;
/*
 * 	注解：以@开头
 */
public class ExtendsDemo5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

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

class NewPhone extends Phone{
	@Override
	public void call() {
		System.out.println("录音");
		super.call();
		//System.out.println("打电话");
	}
}

方法重写的注意事项：

• 子类不能重写父类的私有方法
• 权限修饰符必须大于等于父类方法的权限

继承方法中构造方法的执行顺序

• 在有子父类继承关系的类中，创建子类的对象，调用子类的构造方法，如果子类构造方法的第一行代码没有调用父类的构造方法，则会默认调用父类的无参构造
• 肯定会先执行父类的构造，因为要先给父类的成员变量进行初始化，子类可能会使用到
• 我们可以使用super()在子类构造方法的第一行中调用父类的构造方法

package com.it01;
public class ExtendsDemo6 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Die d = new Die();//我是父类无参构造
		Zi z = new Zi();//我是父类无参构造----我是子类无参构造
		//Zi z1 = new Zi(6);//我是父类无参构造----我是子类有参构造
		

	}

}

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

class Zi extends Die{
	public Zi() {
		//this(1);//我是子类有参构造---我是子类无参构造
		//super(1);//我是父类有参构造----我是子类无参构造
		System.out.println("我是子类无参构造");
	}
	public Zi(int num ) {
		System.out.println("我是子类有参构造");
	}
	
}

this关键字和super的区别

this：当前对象的引用

• 调用子类的成员变量
• 调用子类的成员方法
• 在子类的构造方法第一行，调用子类其他构造方法

super：子类对象的父类引用

• 调用父类的成员变量
• 调用父类的成员方法
• 在子类的构造方法第一行调用父类的构造方法

package com.it01;

public class ExtendsDemo7 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Zi1 z = new Zi1();
		z.function();

	}

}


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

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

抽象

abstract:用于修饰方法和类
抽象方法：不同类的方法使相似的，但是具体内容又不太一样，所以我们只能抽取声明，没有具体的方法体。
抽象类：有抽象方法的类一定是抽象类

注意：一个类继承了抽象类需要重写他所有的抽象方法，否则这个类就得是抽象类

package com.it02;
public class AbstractDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
	

}
//抽象类
abstract class Animals2{
	public abstract void eat();
	//非抽象方法子类可以不用重写
	public void run() {
		
	}
}

class Cat2 extends Animals2{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("猫吃鱼");
		
	}

}

class Dog2 extends Animals2{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("狗吃屎");
	}
}

抽象类的特点

• 抽象方法只能在抽象类中
• 抽象类和抽象方法只能用abstract修饰
• 抽象类不能被实例化
• 抽象类可以有非抽象得方法
• 抽象类和类得关系也是继承

package com.it02;

public class AbstractDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

//抽象类
abstract class Animals{
	public abstract void eat();
	
	public void run() {
		
	}
}
class Cat extends Animals{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("猫吃鱼");
		
	}

}

class Dog extends Animals{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("狗吃屎");
	}
}

抽象类的成员特点
抽象类得成员特点：
成员变量

• 可以有成员变量
• 可以有常量
  成员方法
• 可以有抽象方法
• 可以有非抽象方法

构造方法

• 可以有构造方法，需要对抽象类得成员变量进行初始化
  final：修饰类、成员变量和方法

package com.it02;
public class AbstractDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}
//抽象类
abstract class Animals1{
	
	String name ="哮天犬";
	final int num=10;
	
	public Animals1() {
		System.out.println("我是抽象类得构造");
	}
	
	public abstract void eat();
	
	public void run() {
		
	}
}
class Cat1 extends Animals1{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("猫吃鱼");
		
	}

}

class Dog1 extends Animals1{
	
	public void barking() {
		System.out.println(name);
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("狗吃屎");
	}
}

抽象类的两个实例

实例1

package com.it03;
/*
 * 	小学老师   大学老师
 * 
 * 	共性
 * 		属性-姓名，年龄，性别
 * 		形为-讲课
 */
public class AbstractTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BasicTeacher bt = new BasicTeacher();
		bt.name="刘老根";
		bt.teacher();//刘老根讲解小学课程
		
		JobTeacher jt = new JobTeacher();
		jt.name="李宝库";
		jt.teacher();//李宝库讲解大学课程
		}

}

abstract class Teacher{
	
	String name;
	int age;
	String gender;
	
	public abstract void teacher();
}

class BasicTeacher extends Teacher{

	@Override
	public void teacher() {
		// TODO Auto-generated method stub
		System.out.println(name+"讲解小学课程");
	}
	
	
}


class JobTeacher extends Teacher{

	@Override
	public void teacher() {
		// TODO Auto-generated method stub
		System.out.println(name+"讲解大学课程");
	}
	
	
}

实例2

package com.it03;
/*
 *  	案例-雇员
 *  	程序员--姓名、工号、薪水、工作内容
 *  	项目经理-姓名、工号、薪水、奖金、工作内容
 */
public class AbstractTest2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Programmer pm  = new Programmer();
		pm.work();
		
		Manger m = new Manger();
		m.work();
	}

}

abstract class Person{
	String name;
	int id;
	int pay;
	
	public abstract void work() ;
	
}

class Programmer extends Person{

	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("写代码");
	}
	
}

class Manger extends Person{
	
	int bonus;

	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("管理项目");
	}
	
}

继承的优缺点

1-  提高代码的复用性
	提高了可维护性
2-	类的耦合性增强了
	开发原则：高内聚低耦合
	内聚：就是自己完成某件事请的能力
	耦合：类与类的关系

抽象类得细节

	抽象关键字abstract不可以和哪些关键字共存？
		final、private
		
	抽象类中有构造函数

	抽象类中一定有抽象方法