Java基础(五)

抽象类
·普通类是一个完善的功能类，可以产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。
·抽象类是指在普通类的结构中增加抽象方法的组成部分。

抽象方法
·抽象方法指没有方法体({})的方法，同时抽象方法还必须使用关键字abstract做修饰
·拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明
ex

abstract class A{
	public void fun(){//普通方法有方法体
		System.out.println("存在方法体的普通方法")
	}
	public abstract void print();//抽象方法
}

抽象类注意点
·无法直接进行实例化操作(当一个类实例化后，这个类就可以调用类中的属性或者方法，但抽象类存在抽象方法，却没有方法体，没有方法体就无法进行调用，无法调用就无法实例化对象)

抽象类使用原则
·抽象方法必须是public或者protected(不能有private，否则不能被子类继承，子类变无法实现该方法)，默认public
·抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理
·抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类
·子类(如果不是抽象类)则必须复写抽象类之中的全部抽象方法，如果子类没有实现父类的抽象方法，则必须将子类也 定义为abstract类(Java抽象类中的抽象方法的参数对应的子类方法的参数必须一致，若不一致则表示子类重载了抽象 的方法)

ex:

abstract class A{
	public void fun(){
		System.out.println("普通方法");
	}
	public void abstract void print();//抽象方法，无方法体，有关键字abstract
}

//单继承

class B extends A{//B是抽象类A的子类，是一个普通类
	@override
	public void print(){//必须复写抽象类A中的抽象方法
		System.out.println("Hello");
	}
	public void print(int a int b){
		System.out.println("抽象类子类重载抽象类方法");
	}
}

public class Test{
	public static void main(String[] args){
		A a=new B();//向上转型
		a.print();//被子类A所复写过的方法
	}
}

抽象类使用限制
·抽象类中存在构造方法，目的为了属性的初始化，且子类对象实例化时依然满足先执行父类构造，再执行子类构造。
ex:

abstract class A{
	public A(){
	    System.out.println("A类构造方法");
	}
	public abstract void print();
}
class B extends A{
	public B(){
		System.out.println("B类构造方法");
	}
	@override
	public void print(){//必须实现抽象类中的方法
		System.out.print("Hello");
	}
}
public class TestDemo{
	public static void main(String[] args){
		A a=new B();
	}
}

A类构造方法
B类构造方法
·抽象类不能使用final声明，因为抽象类必须有子类，而final定义的类不能有子类
·外部抽象类不允许使用static声明，而内部抽象类运行使用static声明
·使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用"外部类.内部类"的形式表示类名
ex:

abstract class A{
	static abstract class B{//static定义的内部类属于外部类
		public abstract void print();
	}
}
class C extends A.B{
	public void print(){
		System.out.println("ok")	
	}
}
public class Test{
	public static void main(String[] args){
		A.B ab=new C();
		ab.print();
	}
}

·可以直接调用抽象类中用static声明的方法，如果要执行类中的static方法，可以在没有对象的情况下直接调用，
抽象类也一样。
ex:

abstract class A{
	public static void print(){
		System.out.println("Hello");
	}	
}
public class Test{
	public static void main(String[] args){
		A.print();//直接调用抽象类中的static声明的方法print
	}
}

·有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类，在系统类库中比较常见，目的是对 用户隐藏不需要知道的子类
ex:

abstract class A{//抽象类
	public abstract void print();//抽象方法
	private static  class B extends A{//内部抽象类
		public void print(){//复写抽象方法
			System.out.println("Hello");
		}
	}

}
public static A instance(){

	return new B();	
}
public class Test{
	public static void main(String[] args){
		A a=A.instance();	
		a.print();
	}
}
fun(new P());//A a=new P();
a.command(A.EAT)//new P().command(1)    
abstract class A{
	public static final int EAT=1;
	public static final int WORK=1;
	public static final int SLEEP=1;
	public abstract eat();
	public abstract sleep();
	public abstract work();
	public void command(int flags){
		switch(flags){
		case EAT:
			this.sleep();
			break;
		case SLEEP:
	
	        case WORK:
	
		default:
			break;
		}
	}
}

class R extends A{
	eat(){}
	sleep(){}
	work(){}
}


class M extends A{
	eat(){}
	sleep(){}
	work(){}
}

class P extends A{
	eat(){}
	sleep(){}
	work(){}
}

public class Test{
	public static void fun(A a){
		a.command(A.EAT)
		a.command(A.SLEEP)
		a.command(A.WORK)

	}
	public static void main(String[] args){
		fun(new R());// A a=new R();
		fun(new M());
		fun(new P());	
	}
}

接口

何时使用抽象类何时使用接口
1·抽象类和其子类是是不是的关系(程序员和项目经理都是员工)。
2·接口和其子类是具不具备，有没有的关系(鸟和飞机都具有飞的特性)。

区别
1.抽象类中有抽象方法也可以有非抽象方法，但接口所有的方法都是抽象方法。
2·抽象类只能单继承，接口可以多继承。
3.抽象类内部可能包含非final的变量，而接口中存在的变量一定是final，public，static的。

概念
一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)
接口可以是一个特殊的类，由全局变量和公共的抽象方法组成，接口是解决Java无法使用多重继承的一种手段
接口是100%抽象类，接口的方法必须全部是抽象方法
接口只有常量和方法，常量用public static final修饰，方法用public abstract修饰

接口的特点
和类一样，接口也能够拥有方法和属性，但在接口中声明的方法默认是抽象的(只有方法标识符，没有方法体)，支持多继承

为何使用接口
·Java不支持多继承，通过接口弥补这个缺陷
·实现解耦

语法实现
声明接口用interface关键字，实现接口用implements关键字
ex:

interface Fly
{
	final int a = 10;
	void display();
}
class Test implements Fly
{
	public void display(){
		System.out.println("实现接口的抽象方法");
	}
}
class testclass{
	public static void main(String[] args){
		Test test=new Test();
		test.display();
		System.out.println(a);
	}
}

重点
·不能直接实例化一个接口，接口中的方法都是抽象的，是没有方法体。
·使用接口类型的引用指向一个实现该接口的对象，并且可以调用这个接口中的方法。
(如果某个类实现了某个接口后，那么这个类就具备了接口的功能，那么我们就可以不用这个类的引用去指向这个对象，直接使用接口类型的引用去指向这个类)。(一个父类的引用可以引用一个子类的对象)
Fly test =new Test();//Fly 接口类引用指向实现Fly接口的对象
·一个类可以实现不止一个接口
·一个接口可以继承另一个接口，或者另一些接口，接口也可以继承，并且可以多继承
·一个类要实现某个接口，name它必须要实现这个接口中的所有方法
·接口中的所有方法都是抽象和public的，所有属性都是public static 和final的
·接口用来弥补类无法实现多重继承的局限
·实现解耦