博客

继承的概述

继承的格式和使用

/*
 * 继承：多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），在让多个类去继承这个父类，我们的多个类就可以获取到父类中的成员了。
 * extends
 * 
 */
public class ExtendsDemo {
	public static void main(String[] args) {
		DotA1 d = new DotA1();
		d.start();
		
		LOL1 l = new LOL1();
		l.start();
	}
}
 
class Game1 {
	String name;
	double version;//版本号
	String agent;//代理商
	
	public void start() {
		System.out.println("游戏启动了");
	}
	
	public void stop() {
		System.out.println("游戏关闭了");
	}
}
 
class DotA1 extends Game1 {
	/*String name;
	double version;//版本号
	String agent;//代理商
	
	public void start() {
		System.out.println("游戏启动了");
	}
	
	public void stop() {
		System.out.println("游戏关闭了");
	}*/
}
 
class LOL1 extends Game1 {
	/*String name;
	double version;//版本号
	String agent;//代理商
	
	public void start() {
		System.out.println("游戏启动了");
	}
	
	public void stop() {
		System.out.println("游戏关闭了");
	}*/
	
}

继承的特点

  class A{}

   class B{}

   class C extends A,B{}  // C类不可以同时继承A类和B类

  class A{}

   class B extends A{}

   class C extends A{}   // 类B和类C都可以继承类A

class A{}

class B extends A{}   // 类B继承类A，类B是类A的子类

class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类

/*
 * Java中继承的特点：
 * 			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 {
	
}

继承中成员变量的特点

方法重写的应用场景和注意事项

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();
	}
}

继承优缺点：

final关键字

public class FinalDemo {
	public static void main(String[] args) {
		//Animal a = new Animal();
		//a.eat();
		
		Dog d = new Dog();
		//d.eat();
		
		//d.num = 20;
		System.out.println(d.NUM);
	}
}
 
/*final*/ class Animal {
	public final void eat() {
		System.out.println("吃东西");
	}
}
 
class Dog extends Animal {
	/*public void eat() {}*/
	
	final int NUM;
	
	public Dog() {
		NUM = 10;
	}
}

抽象类概述

                abstract:关键字，用于修饰方法和类

                抽象方法：不同类的方法是相似，但是具体内容又不太一样，所以我们只能抽取他的声明，没有具体的方法体，没有具体方法体的方法就是抽象方法

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

public class AbstractDemo {
 
}
 
abstract class Animal1 {
	public abstract void eat();
	
	//非抽象方法子类可以不重写
	public void run() {
		
	}
}
 
class Cat1 extends Animal1 {
 
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
		
	}
	
	/*public void eat() {
		System.out.println("猫吃鱼");
	}*/
}
 
abstract class Dog1 extends Animal1 {
	/*public void eat() {
		System.out.println("狗吃屎");
	}*/
}

抽象类的特点

public class AbstractDemo2 {
	public static void main(String[] args) {
		//Animal a = new Animal();
	}
}
 
abstract class Animal2 {
	public abstract void eat();
	
	public void run() {
		
	}
}
 
class Cat2 extends Animal2 {
 
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}
 
}

抽象类的成员的特点

public class AbstractDemo3 {
	public static void main(String[] args) {
		Dog d = new Dog();
		d.barking();
	}
}
 
abstract class Animal {
	String name = "哮天犬";
	final int num = 10;
	
	public Animal() {
		System.out.println("我是抽象类的构造方法");
	}
	
	public abstract void eat();
	
	public void run() {}
}
 
class Dog extends Animal {
	public void barking() {
		System.out.println(name);
		System.out.println(num);
	}
 
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}
}

抽象类的细节

接口的概述

              Java语言的继承是单一继承，一个子类只能有一个父类

              Java语言给我们提供了一种机制，用于处理继承单一的局限性的，接口

              接口：接口是一个比抽象类还抽象的类，接口里所有的方法全是抽象方法，接口和类的关系是实现，关键字为:implements   interface

接口的使用

 在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。

public class InterfaceDemo {
	public static void main(String[] args) {
		BillGates gates = new BillGates();
		gates.code();
	}
}
 
 
class Boss {
	public void manage() {
		System.out.println("管理公司");
	}
}
 
class Programmer {
	public void code() {
		System.out.println("敲代码");
	}
}
 
//比尔盖茨
class BillGates extends Programmer {
	
}

接口中成员的特点

接口和类的关系

接口优点

接口和抽象类的区别