Java中的类的高级特性

1、抽象类

1、抽象类：只声明方法的存在而不去具体实现它的类。

抽象类不能被实例化，即不能创建其对象。

定义时在class关键字前加关键字abstract

abstract class 类名 {
   类体
}

2、抽象方法（在抽象类中创建的、没有实际意义的且要子类重写的方法）

没有方法体，只有方法的声明，没有方法的实现

public abstract class A {
    public abstract void a();

public class B extends A {
	@Override
	public void a() { //重写父类中的方法，没有abstract关键字
		
	}
}

抽象方法不能使用private或static关键字进行修饰。

3、抽象类的特点

1、抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。

2、抽象类不可以直接创建对象，原因：调用抽象方法没有意义。

3、只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。否则该子类还是一个抽象类。即重写父类中全部的抽象方法后，子类才能被实例化。

4、抽象类中一定有构造器，即可以写构造方法，便于子类对象实例化使用

之所以继承抽象类，更多的是在思想，是面对共性类型操作会更简单。

2、内部类

内部类定义时不要加public修饰符

1、成员内部类

①作为外部类的成员：调用外部类的结构，可以被static修饰，可以被public、 protected、private等修饰
②作为一个类：可以定义属性、方法、构造器等，可以用final、abstract修饰

1、成员内部类的定义

public class OuterClass {  //外部类
    private class InnerClass {  //内部类
    }
}

public class OuterClass {
	private int i = 0; //用private修饰的成员变量
	private void g() { //用private修饰的成员方法
		
	}
	class InnerClass{
		void f() {
			g();
			i++; //内部类中可以随意使用private修饰的变量
		}
	}
}

内部类的实例一定要绑定在外部类的实例上，即在外部类中初始化一个内部类对象

内部类的初始化使用new关键字

public class OuterA {
	class InnerB {
		InnerB() { //内部类构造方法
			
		}
		public void inf() { //内部类成员方法
			
		}
		int a=0; //内部类成员变量
	}
	
	InnerB in = new InnerB(); //在外部类实例化内部类对象引用
	public void outf() { 
		in.inf(); //在外部类方法中调用内部类方法
	}
	
	public InnerB dob() { //外部类方法，返回值为内部类引用
		//a=4;    //外部类不可以直接访问内部类成员变量
		in.a = 4;
		return new InnerB(); //返回内部类的引用
	}
	public static void main(String[] args) {
		OuterA out = new OuterA(); //内部类的实例化操作必须在外部类或外部类中的非静态方法中实现
		OuterA.InnerB in = out.dob(); //在外部类之外实例化内部类对象，使用“外部类.内部类”的形式指定对象的类型
	}
}

2、使用this关键字获取内部类与外部类的引用

public class TheSameName {
	private int x;
	private class Innner {
		private int x=9;
		public void doit(int x) {
			x++; //调用的是形参x
			this.x++; //调用内部类的变量x
			TheSameName.this.x++; //调用外部类的变量x
		}
	}
}

public class test {
	public static void main(String[] args) {
		TheSameName t = new TheSameName(); //先实例化外部类的对象
		TheSameName.Innner i = t.new Innner(); //才能实例化内部类的对象，使用TheSameName.Innner i创建对象，使用t.new
		i.doit(2);
	}
}

运行结果

2、局部内部类

在类的方法中定义的内部类

public class SellOutClass {
	private String name; //私有成员变量
	public SellOutClass() { //构造方法
		name="苹果";
	}
	public void sell(int price) {
		class Apple { //局部内部类
			int a=0;
			public Apple(int price) { //构造方法
				a=price; 
			}
			public void price() { //局部类中的方法
				System.out.println("现在开始销售"+name);
				System.out.println("单价为："+a+"元");
			}
		}
		Apple apple = new Apple(price); //在这里就要实例化Apple类对象
		apple.price(); //调用局部内部类的方法
	}
	public static void main(String[] args) {
		SellOutClass s = new SellOutClass();
		s.sell(100);
	}
}

运行结果

注意：sell()方法不能访问Apple内部类，但是内部类可以访问其中的常量和外部类的所有成员。

3、匿名内部类

1、定义

return new A() {
			...//类体
		};
		//其中A位为对象名

注意：匿名内部类最后有“ ; ”分号

2、实例

public interface USB {
	public void start();
}

public class Computer {
	public void transfer(USB usb) { //将对象作为形参
		usb.start(); //调用接口中的start方法
	}
}

public class USBTest {
	public static void main(String[] args) {
		Computer c = new Computer();
		USB phone = new USB() {
			@Override
			public void start() {
				System.out.println("手机可以连接USB"); //匿名内部类
			}	
		};
		c.transfer(phone);
	}
}

运行结果

4、静态内部类

在内部类前添加修饰符static，就是静态内部类。

静态内部类的特点：

①不可以使用外部类的非静态成员
②创建静态内部类的对象，不需要其外部类的对象
③不能从静态内部类的对象中访问非静态外部类的对象。
一个静态内部类中可以声明static成员，但在非静态内部类中不可以声明静态成员。
例子

public class StaticInnerClass {
	static int x=100; //只能定义一个静态成员
	static class Inner { //静态内部类
		static void doitInner() { //静态方法
			System.out.println("外部类的成员变量"+x); //调用外部类的成员变量x
		}
		public static void main(String[] args) {
			doitInner(); //访问内部类的方法
		}
	}
}

运行结果