面向对象-抽象类和接口-初解

抽象类

概念

• Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。
  抽象类可以理解为是一个只有方法声明没有方法体的特殊类。

理解：单继承，规范性没有接口强，多用于多态，使用abstract定义，可以有普通方法和变量，可以有构造方法用于实例化子类对象。

特点

• 1、 通过java关键字abstract实现public abstract class 类名{}

• 2、 可以修饰方法或者类，abstract可以修饰方法，也可以修饰类，分别是抽象方法和抽象类。

• 3、 抽象类中可以没有抽象方法（由子类去实现），抽象类中可以存在普通方法，也可以有普通变量和常量，那么抽像类中是可以不用有抽象方法的。

• 4、 如果类中有抽象方法，那该类必须定义为一个抽象类
  抽象类中可以没有抽象方法，但是当一个类中含有抽象方法时这个必须就是抽象类。

• 5、 子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
  当父类抽象类中有抽象方法时，子类继承后要么实现所有抽象方法，要么变为抽象类，当父类抽象类中没有抽象方法时，子类可以实现抽象类，这时子类就变成了一个抽象类。

• 6、 多用于多态中
  多态是子类对父类方法的重写，而抽象类要实现的话，必须有子类继承它，这么一看，抽象类抽象方法实现这个过程就是多态中子类对父类方法的重写。

• 7、 抽象类不可以被实例化
  抽象类是不能被实例化的。

• 在抽象类中具有构造器吗？具有，虽然抽象类不能被实例化，但是我的抽象类的构造器却可以给子类对象实例化，就相当于多态中的父类引用指向子类对象。

• 抽象类的好处是什么？抽象类更像是一种约束，约束在代码实现时的规范，抽象类像是法律，只是指定规则，而具体的实现则是交过法官警察，交给子类去实现。

老师实例：

public class 抽象类 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建对象ct，调用抽象类中的成员变量和成员方法。
		cgbteacher ct = new cgbteacher();
		//调用实现后的抽象方法
		ct.teach();
		ct.setName("和林");
		ct.setAge(25);
		ct.print();
		actteacher at = new actteacher();
		at.teach();
		at.setName("李");
		at.setAge(30);
		at.print();
		teacher t = new cgbteacher();
		t.teach();
		t.setName("yang");
		t.setAge(35);
		t.print();

	}

}
// 通过java关键字abstract实现
//分析老师案例
abstract class teacher{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	//抽象方法
	public abstract void teach();
	public void print(){
		System.out.println(name+"......"+age);
	}
}
//子类1
class cgbteacher extends teacher{
	//对抽象方法的实现，对抽象方法的实现不需要加上abstract，只要方法的其他部分即可，如果再加上abstract那么子类就会变成抽象类
	public void teach(){
		System.out.println("主打互联网架构的讲解");
	}
}
class actteacher extends teacher{
	public void teach(){
		System.out.println("主打高薪冲刺");
	}
}

接口

概念

• Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。
  Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。

理解：接口是只有规范，自己无法写方法，无法写变量，没有构造方法，接口更像是法律，只有约束，没有实现。接口最突出的特点是多实现，在Java中只能单继承，那么如果要实现多个继承的话可以使用接口的多实现也可以实现相同的效果。（在jdk1.8后有所改变，可以有静态方法和default修饰的方法存在）

关键字：interface接口定义，implements接口实现

特点

• 1、 接口中都是抽象方法——接口中只能有抽象方法（在jdk1.8版本后，在接口中可以有default修饰的方法和静态方法（static）存在并且有方法体）

• 2、 通过interface关键字创建接口

public interface 接口名{}
interface 接口名{}

• 3、 通过implements让子类来实现

public class 类名 implements 接口1，接口2{}

• 4、 可以理解成，接口是一个特殊的抽象类——接口很相似，可以对比看一看

• 5、 接口突破了java的单继承的局限性——接口最主要的特点就是解决了Java单继承的缺点，通过接口的多实现可以起到多继承的作用

• 6、 接口和类之间可以多实现，接口和接口之间可以多继承

//多继承——接口与接口
public interface 接口名 extends 接口1,接口2{}
//多实现——类与接口
public class 类名 implements 接口1,接口2{}

• 7、 接口是对外暴露的规则，是一套开发规范
  接口是一种规范代码的作用，是对外可见的，相当于接口由架构师写好以后，里面的内容，里面的实现，就由下面的成员去完成，去实现里面的方法。
• 8、 接口提高了程序的功能扩展，降低了耦合性
  接口的多实现扩展了程序的功能，在多实现的基础上，程序功能更加多样化。同时，接口只定义抽象方法，不实现这种规范和多实现的特点，使得类之间，程序之间的耦合性降低，不像之前的继承是高耦合的。

注：

• 接口里是没有构造方法的。在创建实现类的对象时默认的super()，是调用的默认Object的无参构造。
• 接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final
• 接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。

接口内变量为常量，不可更改。

实例：

public class 接口 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//实例化zix类对象，调用实现的抽象方法。
		zix z = new zix();
		z.fj();
		z.fi();
		//使用接口名调用接口内的静态方法
		ax.ff();		
	}
}
interface ax{
	int a = 10;
	public void fj();
	//jdk1.8以后的新特性 ：接口中就可以有静态方法和普通方法，但是普通方法要被default修饰，也可以有方法体。
	public static void ff(){
		System.out.println("接口里的静态方法");
	}
}
interface ay{
	int b = 10;
	public void fi();
}
class zix implements ax,ay{
	public void fj(){
		System.out.println("实现ax接口的抽象方法");
	}
	public void fi(){
		System.out.println("实现ay接口的抽象方法");
	}
}

结果：

总结

1、 类与类的关系：

-- 是继承关系，java只支持单继承 class A extends B

2、 类和接口的关系：

--实现关系 class x  implements A

-- 类需要把A接口里的所有抽象方法重写

--多实现 class x implements A,B

-- 类需要把A,B接口里的所有抽象方法重写

--可以在继承的同时多实现，注意要先继承后实现

-- //A是类，B也是类，C和D是接口

--class A extends B implements C,D{

3、 接口和接口的关系：

   --  继承关系 interface c extends A

   --  多继承  interface c extends A,B