从入门到放弃的第二周（面向对象）......day.10.。。。。。抽象类。接口；

1，抽象类

 

使用abstract修饰的类，其中可能有abstract方法

特点：抽象类不可实例化

具体的子类继承了抽象类，必须实现(重写 override)抽象父类中所有的抽象方法
抽象类中可以有构造方法，它是被子类的构造方法中的super()

(1)定义一个抽象类Weapon,该抽象类有两个抽象方法attack()，move()：这两个方法分别表示武器的攻击方式和移动方式。
(2)定义3个类：Tank,Flighter,WarShip都继承自Weapon,分别用不同的方式实现Weapon类中的抽象方法。
(3)写一个类Army,代表一支军队:
这个类有一个属性是Weapon数组w（用来存储该军队所拥有的所有武器）；
该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,并用这一大小来初始化数组w。
该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。
在这个类中还定义两个方法attackAll()和moveAll()，让w数组中的所有武器攻击和移动。
(4)写一个主方法去测试以上程序。

 

public class Army {
	private int x;
	static int y = 0;
	public Army(int x) {
		this.x = x;
		w = new Weapon[x];
	}
	public int getX() {
		return x;
	}
	Weapon[] w;
	public void addWeapon(Weapon wa) {
		if (y == x) {
			return;
		} else {
			w[y] = wa;
			y++;
		}
	}
	public void attackAll() {
		for (int x = 0; x < y; x++) {
			w[x].attack();
		}
	}
	public void moveAll() {
		for (int x = 0; x < y; x++) {
			w[x].move();
		}
	}
}

　　

 

public class Flighter extends Weapon {

	@Override
	public void attack() {
		System.out.println("feiji biubiubiu");		
	}
	@Override
	public void move() {
		System.out.println("feiji qianjin");	
	}
}

　　

public class Tank extends Weapon{

	public void attack() {
		System.out.println("tank biubiubiu");		
	}
	@Override
	public  void move() {
		System.out.println("tank qianjin");		
	}
}

　　

public class Warship extends Weapon {
	@Override
	public void attack() {
		System.out.println("haijun biubiubiu");		
	}
	@Override
	public void move() {
		System.out.println("haijun qianjin");	
	}
}

　　

public abstract class Weapon {
   
	
	protected abstract void attack();
	protected abstract void move();
}

　

public class Test {
	
	public static void main (String[] args){
	    Army army=new Army(18);
             
        Weapon t1=new Tank();
        Weapon t2=new Flighter();
        Weapon t3=new Warship();
        Weapon t4=new Tank();
	
	    army.addWeapon(t1);
	    army.addWeapon(t2);
	    army.addWeapon(t3);
	    army.addWeapon(t4);
	    
	    army.attackAll();
	    army.moveAll();
}}

　　

　

2，接口：Interface，它是一直能力的体现；接口是一种协议

 

语法：使用interface声明接口
在接口中可以有成员（public static final修饰的）
在接口中拥有若干抽象方法

在JDK1.8，提供了default方法
使用implements实现接口，意味着要将接口中所有的抽象方法都实现(重写)，抽象类可以不实现接口的方法

 

1，声明接口 Talkable (say) ,Walkable (walk)
2,声明接口的实现类，实现上面的两个接口中的抽象方法
3，测试，实例化子类，调用其say，walk

 

 

利用接口做参数，写个计算器，能完成加减乘除运算。
（1）定义一个接口Computable含有一个方法int computer(int n, int m)。
（2）设计四个类分别实现此接口，完成加减乘除运算。
（3）设计一个类UseCompute，类中含有方法：public int useCom(Computable com, int one, int two)，此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。
（4）设计一个主类Test，调用UseCompute中的方法useCom来完成加减乘除运算。

 

public class Chu implements Compultable {

	public int  computer(int a,int b) {
		return a/b;		
	}}

　　

public interface Compultable {	
	public int computer(int n, int m);	
}

　　

public class Compultabletest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
           Usecompultabe usecompultabe=new Usecompultabe();
           
           Compultable jia=new Jia();
           
           System.out.print(jia.computer(1, 2));
           usecompultabe.useCom(jia, 1,2);
	}
}

　　

public class Jia implements Compultable {
	public int  computer(int a,int b) {
		return a+b;		
	}	
}

　　

public class Jian implements Compultable {
	public int  computer(int a,int b) {
		return a-b;		
	}}

　　

 

 

 

接口与抽象类的区别：
1，接口语法：interface，implements 接口可以同时实现多个，除了static，抽象方法，default，
抽象类：absttract，extends 抽象类只能单继承
2，设计：
接口：表达某种能力，一种约定
抽象类适合表示继承层次上出现的实体
相同：1，不能实例化 2，可以有抽象方法

3，内部类 （InnerClass）
在类的内部，方法的内部，代码块

 

蓝廋香菇