抽象类&接口

------ Java培训、Android培训、iOS培训、.Net培训 、期待与您交流！ -------

抽象类

1.抽象类和抽象方法必须用abstract关键字修饰

2.抽象类中不一定有抽象方法，但是有抽象方法的类，必须定义为抽象类。

3.抽象类不能实例化

因为它不是具体的

抽象类有构造方法，但是不能实例化，用于子类访问父类数据初始化。

通过多态可以实例化，因为重写了抽象方法。

例子：Fu f = new Zi(); 

 f.show();

4.抽象类的子类

1)如果不想抽象方法，该子类可以定义为抽象类。

2)重写所有抽象类方法，这时，变是一个具体的类。

抽象类的成员特点：

成员变量：既可以是变量，也可以是常量。

构造方法：有。用于子类访问父类数据的初始化。

成员方法：既可以是抽象的，也可以使非抽象的。

抽象类的成员方法特性：

1)抽象方法 强制要求子类重写。

2)非抽象方法 子类继承父类，提高代码复用性。

一个抽象类的例子：

员工： 姓名，工号，工资，工作内容(员工职位不同，工作内容不同)

普通员工：    姓名，工号，工资，工作内容

经理: 姓名，工号，工资，奖金，工作内容

                /**
		*	员工
		*/
		abstract class Employee{
			private String name;
			private String id;
			private String salary;
			
			public Employee(){}
			public Employee(String name,String id,String salary){
				this.name = name;
				this.id = id ;
				this.salary = salary;
			}
			public String getName() {
				return name;
			}
			public void setName(String name) {
				this.name = name;
			}
			public String getId() {
				return id;
			}
			public void setId(String id) {
				this.id = id;
			}
			public String getSalary() {
				return salary;
			}
			public void setSalary(String salary) {
				this.salary = salary;
			}
			@Override
			public String toString(){
				return "姓名："+name+"工号:"+id+"工资:"+salary;
			}
			//抽象方法 因为不同职位的人，他工作的内容不一样，此处应该留着让子类去实现自己的内容
			abstract void doWork();
		}
		/**
		*	普通员工
		*/
		class GeneralStaff extends Employee{
			public GeneralStaff(){}
			public GeneralStaff(String name,String id,String salary){
				super(name,id,salary);
			}
			public void doWork(){
				System.out.println("写代码");
			}
		}
		/**
		*	经理
		*/
		class Manager extends GeneralStaff{
			private String bonus;
			public Manager(){};
			public Manager(String name,String id,String salary,String bonus){
				super(name,id,salary);
				this.bonus = bonus;
			}
			public void setBonus(String bonus){
				this.bonus = bonus;
			}
			public String getBonus(){
				return bonus;
			}
			@Override
			public void doWork() {
				System.out.println("谈业务");
			}
			@Override 
			public String toString(){
				return super.toString()+"奖金:"+bonus;
			}
		}
		
		public class Test1{
			public static void main(String[] args){
				Employee e = new Manager("小明","1","1000元","200元");
				//多态
				e.doWork();
				System.out.println(e.toString()); 
				
				System.out.println("-----------------------");
				
				GeneralStaff gg = new GeneralStaff("小王","2","500元");
				gg.doWork();
				System.out.println(gg.toString());
			}
		}
		输出结果：
			谈业务
			姓名：小明工号:1工资:1000元奖金:200元
			-----------------------
			写代码
			姓名：小王工号:2工资:500元

一个类如果没有抽象方法，可不可以定义为抽象类？
答：可以，不可以实例化，只能继承。
abstract不能和哪些关键字共存：
private 冲突 抽象方法使用来被继承的 
final        冲突         。。。。。
static 无意义 方法体中没有实现，调用无意义。
可以存在静态实现方法，可以直接调用。



接口：
接口使用关键字interface关键字定义
类实现接口使用implements关键字实现。
接口不能实例化，按照多态的方式，有具体的子类实例化。其实这也是多态的一种，接口多态。
实现接口的子类，要么是抽象类，要么重写接口中的所有方法。

接口成员特点：
成员变量：  只能是常量，并且是静态的。
默认修饰符： public static final
建议手动给出
构造方法：  接口中没有构造方法

成员方法：  只能是抽象方法
默认修饰符: public abstract
   建议手动给出
在Java中类于类：
继承关系，只能单继承，可以多层继承。
类与接口：
实现关系，可以单实现，可以多实现
可以在继承一个类的情况下，实现多个接口
接口与接口：
继承关系，可以继承多个接口。
例：

                interface A{
			public abstract a();
		}
		interface B extends A{
			public abstract b();
		}
		interface C extends B{
			public abstract c();
		}	
		abstract class D implements A,B,C{
			
		}

当一个 抽象类实现一个接口时，可以重写接口中的方法，也可以拿到过当抽象方法。
抽象类与接口的区别：
成员区别：
抽象类：
成员变量： 可以是变量，可以是常量
构造方法： 有，子类初始化
成员方法： 可以是抽象，可以是非抽象
接口：
成员变量： 只可以是静态常量
成员方法： 只可以是抽象
设计理念区别：
抽象类 被继承体现的是："is a"的关系。抽象类中定义的是该类继承体系的共性功能。

接口   被实现体现的是："like a"的关系。接口中定义的是该继承体系的扩展内容。

多态：

大家都直到抽象类和接口是不能实例的，但是可以使用多态，看下面的例子：

         public class Test{
		public static void main(String[] args){
                       //牵扯到内部类  没学到这的话  去看下内部类
			JK oc = new JK(){
				@Override
				public void method() {
				System.out.println("hello");
				}
			};
		//此时调用的就是重写接口中的方法
		new OnClickListener(oc) .start();

		}
	}
	class OnClickListener{
		private JK oc;
		public OnClickListener(JK oc){
			this.oc = oc;
		}
		public void start(){
			oc.method();
		}
	}
	interface JK{
 		public abstract void method();	
	}
	//运行结果：
	// hello