JAVA继承综合小练习

继承小练习

代码

package 继承小例子之吃鸡;

class Wapon{
	String name;
	
	void waponAttack() {
		System.out.println("武器攻击");
	}
}

class K98 extends Wapon{
	void waponAttack() {
		System.out.println("98K攻击!800M打头!");
	}
}

class M4 extends Wapon{
	void waponAttack() {
		System.out.println("M4攻击!突突他!");
	}
}

class Play{
	String name;
	String duanwei;
	
	Wapon wapon;
	
	void printInformation() {
		System.out.println("名字:"+name+"段位:"+duanwei);
	}
	
	void attack() {
		System.out.println("玩家攻击");
		wapon.waponAttack();
	}
}

public class ChiJi {
	public static void main(String[] args) {
		Play play1 = new Play();
		play1.name = "Finny";
		play1.duanwei = "大师";
		
		play1.printInformation();
		
		play1.wapon = new K98();
		play1.attack();
		
		play1.wapon = new M4();
		play1.attack();
	}
}

结果

名字:Finny段位:大师
玩家攻击
98K攻击!800M打头!
玩家攻击
M4攻击!突突他!

继承简单工厂模式例子

代码

package 继承之简单工厂模式;

class Fruit
{
	String name;
	
	void grep() {
		System.out.println("疯狂生长的水果");
	}
	
	public Fruit(String name) {
		this.name = name;
	}
}

class Apple extends Fruit
{
	void grep() {
		System.out.println("疯狂生长的苹果");
	}
	
	public Apple(String name) {
		super(name);
	}
}

class pineapple extends Fruit
{
	void grep() {
		System.out.println("疯狂生长的菠萝");
	}
	
	public pineapple(String name) {
		super(name);
	}
}

class Factory//工厂类
{
	public static Fruit getFruit(String name)
	{
		if(name == "苹果") {
			return new Apple("苹果1");
		}
		if(name == "菠萝") {
			return new pineapple("菠萝1");
		}
		return null;
	}
}

public class Test {
	public static void main(String[] args) {
		Factory.getFruit("苹果").grep();
		Factory.getFruit("菠萝").grep();
	}
}

结果

疯狂生长的苹果
疯狂生长的菠萝

抽象类(模板方法模式)

抽象类概念

抽象类

• Java中可以定义没有方法体的方法，该方法由子类来具体实现。
• 该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。

抽象方法的特点

1. 只有方法头没有方法体的方法称为抽象方法
2. 抽象方法用abstract来修饰
3. 抽象方法代表一种不确定的操作或行为
4. 抽象方法不能被调用

抽象类的特点

1. 定义中含有抽象方法的类叫做抽象类
2. 抽象类用abstract来修饰
3. 抽象类代表一种抽象的对象类型
4. 抽象类不能实例化
5. 抽象类中可以有具体方法，可以没有抽象方法

简而言之 就是抽象类可以没有抽象方法，但抽象方法不能没有抽象类。况且抽象类没有抽象方法没啥意义，还不如不用抽象类。

模板方法模式定义
一个模板方法用一些抽象的操作定义一个算法，而子类将重定义这些操作以提供具体行为

模板方法模式意图
定义了一个操作中一个算法框架，把一些步骤推迟到子类去实现。模板方法模式让子类不需要改变算法结构。

代码

package 抽象类之模板方法模式;

abstract class Control
{
	abstract void openLight();
	abstract void openTV();
	abstract void openCurse();
	
	public void work()
	{
		openLight();
		openTV();
		openCurse();
	}
}

class PcControl extends Control
{

	void openLight() {
		System.out.println("pc openLight");
	}

	void openTV() {
		System.out.println("pc openTV");
	}

	void openCurse() {
		System.out.println("pc openCurse");
	}
}

class AndroidControl extends Control
{

	void openLight() {
		System.out.println("Android openLight");
	}

	void openTV() {
		System.out.println("Android openTV");
	}

	void openCurse() {
		System.out.println("Android openCurse");
	}
}

public class Test {
	public static void main(String[] args) {
		PcControl pc = new PcControl();
		pc.work();
		AndroidControl android = new AndroidControl();
		android.work();
	}
}

结果

pc openLight
pc openTV
pc openCurse
Android openLight
Android openTV
Android openCurse