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(); //访问内部类的方法 } } }

运行结果