Java 基础知识——抽象类、接口和内部类

抽象类、接口和内部类

---

一、 抽象类

在面向对象的概念中，所有的对象都是通过类来表述，但并不是所有的类都能完整的描绘对象。如果类中某方法无法完整的实现，可以将其定义为抽象类。只定义一个"骨架"，对子类的共同行为提供规范，但并不实现，将其具体实现放到子类中完成。

1. 抽象类的声明

声明一个抽象类或者抽象方法使用关键字 abstarct。抽象类示例：

// 抽象类的声明
public abstract class Shape {
 	double dim; 	
 	public Shape(double dim) {
 		this.dim = dim; 	
 	} 	

	// 抽象方法,获得面积 	 
	public abstract double callArea(); 	
	
	// 抽象方法，获得周长 	 
	public abstract double callPerimeter(); 
} 

2. 抽象类的使用

抽象类不能实例化，要通过继承方式使用。且子类一定要定义或者实现父类的抽象方法。
子类中对于父类如果有的方法只定义未实现，要将子类也定义为抽象类。

public class Circle extends Shape {
 	public Circle(double dim) {
 		super(dim); 	
 	} 	
 	// 实现抽象方法 callArea() 	
 	public double callArea() { 		
 		// 返回圆的面积 		
 		return 3.14 * dim * dim; 	
 	} 	

	// 实现抽象方法 callPerimeter() 	
	public double callPerimeter() { 		
		// 返回圆的周长 		
		return 2 * 3.14 * dim; 	
	} 	
	
	public static void main(String[] args) { 		
		// 声明一个Shape对象，指向实现它的子类对象 		
		Shape shape = new Circle(10); 		
		// 调用callArea()求圆的面积，并输出 		
		System.out.println("圆的面积是：" + shape.callArea() ); 		
	} 

3. 抽象类特性

• abstract 抽象方法没有方法体，有抽象方法的类，一定要定义为抽象类。
• 一个抽象类可以含有多个抽象方法，也可以含有已实现的方法。
• 抽象方法必须在子类中被实现，除非子类是抽象类。
• 抽象类不可实例化（不可定义本类对象，不可调用方法），但可以用来创建子类对象。

补充：

• abstract 不能与 final 同时修饰一个类【abstract 类需要被实现，而 final 不允许被继承，矛盾】
• abstract 不能与 static、private、final 或 native 并列修饰同一方法
  【static静态方法属于类，不可能被子类实现】
  【private 方法权限仅本类，不可能被子类实现】
  【final 修饰的方法不能被重写】

---

二、 接口

1. 接口的定义

Java 只支持单一继承，不支持多继承。为了模仿多继承即使用接口，一个类可以实现多个接口。
接口定义的关键字是 interface 。

public interface MultiInterface { 	
	
	// 属性全是静态常量,且必须赋值！！！
	public static final double PI = 3.1415926;  
	String name = "ha";   								// 变量默认 public static final，即也是常量
	
	// 方法全无方法体，且默认public
	public void callArea(); 	

	// 可使用default定义一个含有方法体的方法 (仅限于JDK1.8以后)		
	default void before(){  
		System.out.println("现在开始计算："); 	
	} 
} 

2. 接口特性

• 接口是对抽象类的进一步抽象，是方法声明和常量的定义集合；
• 接口不可以被实例化，但可创建子类对象
• 实现类必须实现接口的所有方法（除了default关键字修饰的）
• 接口中的方法无方法体，变量都是静态常量 且必须赋初值

注意

• 从JDK1.8开始可以使用default关键字来定义一个默认的方法来扩展接口，default关键字修饰的默认方法可以直接调用，不用子类去实现。

3. 接口的实现

通过类实现接口，类使用接口用关键字implements

// 定义了一个接口，接口可以不加修饰符
interface oneTnterface {
    // 定义一个方法，没有方法体。方法名称和返回值类型即可
    void show();
}

interface otherInterface {
    void doOther();
}

class OneClass implements oneInterface, otherInterface {
    String name;
    public void show() { 
    	System.out.println("Interface 1");
    }
    
    public void doOther() {
    	System.out.println("Interface 1=2");
    }
}

---

三、 接口与抽象类

接口更像是定义一种功能或者是操作，实现该接口就去做某些事。
抽象类则是对一些事物的高度概括。

1. 相同之处

• 接口与抽象类的方法均可以不含方法体（抽象类中方法必须声明abstract），也可以含有方法体（接口中必须声明default，且JDK1.8以后）。
• 抽象类与接口两者均不能实例化，但可以创建子类 / 实现类对象。

2. 不同之处

• 接口可以多实现，但是抽象类只能单继承。
• 抽象类中属性可以有变量可以被改变，而接口只能是常量。

3. instanceof 与 typeof

• instanceof 运算符用来判断 是否是某接口/对象的后代。
  （间接继承或实现也算，aq 任意类 instanceof Object）
• typeof () 用来判断对象的实际类型

4. 对象转换

仅仅发生在有继承或实现关系的类中。

Person p = new Teacher();   // 自动
Teacher t = (Teacher)p;		// 强制，且当声明为父类引用状态时，才可强制，否则报错

---

四、 内部类

• 内部类能够隐藏起来，不被同包的其它类所访问。
• 内部类可以访问其所处外部类所有属性
• 回调处理中，匿名内部类便捷

1. 成员内部类

public class OuterClass{
	private int i = 10;
	...
	public void function{
	} 
	
	class InnerClass{
	
	}
}

2. 局部内部类

public class OuterClass{
	private int i = 10;
	...
	public void function{
		// 方法内部
		class InnerClass{
	
		}
	} 	
}

3. 静态内部类

内部类只是为了将其隐藏，不需要和外部发生联系时，可将内部类声明为 static。

public class OuterClass{
	private int i = 10;
	...
	public void function{
	} 
	
	static class InnerClass{
	
	}
}

4. 匿名内部类

局部内部类的特殊化，如果只创建一个类的一个对象（只用一次），可以考虑匿名内部类，在GUI事件处理中大量用到。匿名内部类就是没有名字的内部类。

JButton button = new JButton("button");
	button.addActionListener(new ActionListener(){
		public void actionPerformed（ActionEvent e）{
			System.out.println("Button Clicked");
		}
	});

创建一个实现 ActionListener 接口类的新对象，需要实现的actionPerformed方法定义在{ }内。