面型对象2

abstract（抽象类）

1. 通过抽象类可以避免子类的随意设计
2. 有抽象方法的类就只能定义抽象方法
3. 抽象类不能实列化，不能通过new关键字来实例化抽象类
4. 抽象类可以包含属性，方法，构造器，但是构造方法不能通过new实列，自能被子类来调用、
5. 抽象类只能用来继承
6. 抽象类方法必须被子类实现

 public abstract class Father {	//如果你包含了抽象方法，这个类就必须是抽象类
	int a;						//可以定义普通属性
	public abstract  void run();
	public void speak() {	//	可以定义普通方法
		System.out.println("说话");	
		run();					//可以调用run方法
	}
}
class son extends Father{
	@Override		//重写，注解
	public void run() {
		System.out.println("小跑");
	}	//用sbstract修饰的方法，必须被子类继承
}
class dau extends Father{	//子类必须继承
	@Override
	public void run() {
		System.out.println("慢走");	
	}
}

public class Test {
	public static void main(String[] args) {
		//Father f=new Father();	//报错，Father不能实列化，调用不了
		Father	f=new son();		//父类引用指向子类对象
		f.run();
		f.speak();
	}
}

(抽象方法的意义，将方法的设计和方法的实列分离)
Test

public class HttpServlet {
	public void Servlet() {
		System.out.println("HttpServlet.Servlet");
		doGet();	//this.doGet		//this指向谁就调用谁
	}
	public void doGet() {
		System.out.println("HttpServlet.doGet");
	}
}

public class MyServlet extends HttpServlet {
	public void doGet() {	//重写doGet方法
		System.out.println("MyServlet.doGet");
	}
}

public class test {
	public static void main(String[] args) {
		HttpServlet s =new MyServlet();		//父类引用指向子类对象
		s.Servlet();	//调用Servlet方法
		 
	}
}

> 编译结果
  HttpServlet.Servlet
  MyServlet.doGet		//调用了子类的doGet方法

接口（interface）

1. 接口可以实现多继承
2. 接口修饰只能是public或者默认
3. 接口里面不能定义变量，只能定义常量，方法（abstract)
4. 实现接口（implement）

public interface testinterface {	//interface表示接口
	/*public static final*/	int MAX_AGE=100;	//，常量固定，写于不写都是public static final。
	
	/*public abstract*/ void run();		//方法固定为抽象方法，写于不写都是public abstract
}

class My implements testinterface{	//实现方法	

	@Override
	public void run() {		//必须重写父类抽象类
	System.out.println(MAX_AGE);	//可以调用父类常量
	System.out.println("My.run()");
	}
}

public class testInterface01 {
	public static void main(String[] args) {
		Angel a=new Angel();
		a.fly();
		Volant v=new Angel();
		/*v.help();*/	//报错，因为编译器把angel当作Volant类型，Volant并没有help
		Honest h=new GoodMan();
		h.Help();
	}
}
//飞行接口
interface Volant {
	int FLY_HEIGHT=1000;
	void fly();
}

interface Honest{
	void Help();
}

class Angel implements Volant,Honest{	//实现类可以实现多个父接口
	@Override
	public void Help() {
		System.out.println("Angel.Help()");
	}
	@Override
	public void fly() {
		System.out.println("Angel.fly()");
	}
}
class GoodMan implements Honest{
	@Override
	public void Help() {
		System.out.println("GoodMan.Help()");
	}
}

> 编译结果：
> Angel.fly()
> GoodMan.Help()

接口多继承
接口就是规范

public class testInterface02 {
}
interface A{
	void test1();
}
interface B{
	void test2();
}
interface C extends A,B{	//接口多继承
	void test3();
}
class MyTest implements C{	//实现C
	@Override
	public void test1() {
		System.out.println("MyTest.test1()");
	}
	@Override
	public void test2() {
		System.out.println("MyTest.test2()");
	}
	@Override
	public void test3() {
		System.out.println("MyTest.test3()");
	}
}