【Java】对象、类（抽象类与内部类）、接口

博文内容概况

• 对象和类
• 抽象类
• 接口
• 内部类

对象和类

对象是对客观事物的抽象，类是对对象的抽象。类是一种数据类型，其外观和行为由用户定义。类中可以设置两种类型的元素：字段（有时被称为数据成员）和方法（有时被称为成员函数）。字段可以是任何类型的对象。如果类的某个成员是基本数据类型，即使没有进行初始化，Java也会给它一个默认值，但用户最好自行对其进行初始化。

基本类型	默认值
boolean	false
char	'\u0000'(null)
byte	(byte)0
short	(short)0
int	0
long	0L
float	0.0f
double	0.0d

抽象类

/**
1. 被abstract修饰的类即为抽象类；包含一个或多个抽象方法的即为抽象类
2. 抽象类的权限修饰符为public，缺省（如下）也为public；
3. 抽象类无法创建对象（即不能new）；
4. 其余情况与普通类相同。
*/
abstract class animal {
　　int num;//成员变量可使用任何访问权限修饰词（public、protected、private）
/**
1. 抽象方法必须为public或protected，缺省即为public;
2. 抽象方法没有方法体，即符号{};
3. 子类中必须实现抽象方法，否则子类仍为抽象类。
 */
　　abstract void run();　　　　
}
class lion extends animal{ 　　
　　void run(){}
}

接口

interface提供一个完全抽象的类，没有提供任何具体实现。它允许创建者确定方法名、参数列表和返回类型。

/**
在Java8版本中，接口的功能增强了，接口中允许存在：
1. 变量 - 必须为public static final形式的变量；
2. 抽象方法 - public abstract关键词在接口中可省略；
3. 具体方法 - 以static、default关键词修饰的方法，关键词不可省略（Java8新增的内容）
* 方法默认的权限为public
*/
public interface animal {
	public static final int a = 8;
    //static方法
	static void staticMethod() {
		System.out.println("---animal static method---");
	}
    //default方法
	default void defaultMethod() {
		System.out.println("---animal default method---");
	}
	//抽象方法
	void run();
}

调用static、default方法如下

class lion implements animal {
	public static void main(String[] args) {
		//调用接口中的静态方法——接口名.静态方法名（与调用普通类的静态方法一样）
		animal.staticMethod();
		//调用接口中的default方法   实现接口并实例化该实现类
		lion l = new lion();
		l.defaultMethod();
	}

	@Override
	public void run() {}
}

总结，抽象类和接口之间的异同

（√表示允许存在，×表示不存在）

	抽象类	接口
定义（关键词）	abstract class	interface
类的权限修饰符	public与缺省相同	public、缺省
变量	没有任何限制	必须以public static final修饰
抽象方法	√	√
抽象方法权限修饰符	public、protected、缺省（default）[1.8]	缺省默认为public
构造方法	√	×
普通方法	√	√[1.8]
静态方法	√	√[1.8]
静态块	√	×
继承方式	子类只能继承1个抽象类 抽象类可以继承一个类（抽象类、实体类均可）和实现多个接口 （extends、implements）*	接口可以继承多个接口 子类可以实现多个接口 （implements）**
作用	重用	降低耦合

*子类继承抽象类时需要重写父类所有的抽象方法，可以实例化；若不能完全重写，则该子类仍为抽象类；

**子类实现接口时需要实现全部的抽象方法，否则该子类为抽象类。

内部类

·成员内部类

public class Outer {

	private int num = 8;
	private int out = 10;

	private Inner in = null;
	public Outer() {
		in = new Inner();
	}

	//内部类的访问权限-public、protected（外部类的子孙类可访问）、默认（与外部类同包）、private(只能在外部类内部访问)
	public class Inner{
		private int out;
		public void doSomething() {
			//内部类可直接访问外部类的成员
			System.out.println(num);
			//当内部类拥有外部类同名的成员变量和方法，需要通过[外部类.this.成员变量/成员方法] 进行访问
			System.out.println(Outer.this.out);
		}
	}

	public static void main(String[] args) {
		//成员内部类依靠外部类存在，所以访问内部类时需要一个外部类的对象
		Outer.Inner inner = new Outer().new Inner();
		inner.doSomething();//访问内部类成员方法
		inner.out++;//访问内部类成员变量

	}
}

·静态内部类

public class Outer {
	int a;
	static int b;

	static class Inner{
		public Inner() {
			//System.out.println(a); 编译不通过
			System.out.println(b);//只能访问外部的静态变量
		}
	}

}

·局部内部类

public class Outer {

	public int out;
	public static int out_s;

	public void method() {
		int num;
		class Inner{
			//num++; 编译不通过，无法使用可变的局部变量

			public void print() {
				System.out.println(out++);//可以使用外部类的成员变量
			}
		}
	}

	static void method2() {
		class Inner{

			public void print() {
				System.out.println(out_s++);//static方法中的内部类只能使用静态变量
			}
		}
	}
}

·匿名内部类

/**
1. 匿名内部类是唯一没有构造器的类，用于继承其他类、实现接口；
2. 匿名内部类的好处是使用便捷
3. 通过实例初始化，达到匿名内部类创建一个构造器的效果
如例，Thread()中的部分为Thread的内部类，通过实例（new）Runnable接口达到想要的效果
*/
Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=0;i<100;i++) {
					System.out.println(Thread.currentThread().getName()+i);
				}
			}
		});
		t.start();

	成员内部类	静态内部类	局部内部类	匿名内部类
权限	package,public,protected, private		不允许有public、protected、private、static	不能有访问修饰符
修饰词	成员内部类可看作外部类的一个成员，所以可以像成员一样拥有多个权限修饰词	static（必须）	可以使用final/abstract	不能有static
定义位置	在另一个类的内部， 与成员方法、属性平级		定义在方法、代码块、 作用域（{}中）
访问内部	通过内部类的实例访问
访问外部	（内外部成员名字相同时）外部类.this.成员变量	只能访问静态成员（ 变量/方法）
特点		无需依赖外部类		只能使用一次

参考：

《Java编程思想》

https://www.cnblogs.com/dolphin0520/p/3811445.html（海子:Java内部类详解）

https://www.cnblogs.com/dorothychai/p/6007709.html