一:抽象类
1:抽象方法
(1)抽象方法的语法格式
[访问修饰符]abstract<返回类型><方法名>([参数列表])
(2)普通方法和抽象方法区别:
抽象方法需要用abstract修饰,普通方法不需要
抽象方法没有方法体,普通方法有方法体。
2:抽象类
(1)语法格式:
abstract class<类名>{ }
(2)与普通类的区别
抽象类可以有抽象方法;
抽象类不可以被实例化;
3:定义一个抽象类:
public abstract class 类名{ 修饰符 数据类型 变量名; 修饰符 abstract 返回值类型 方法名称(参数列表); 修饰符 返回值类型 方法名称(参数列表){ } }
4:注意事项
抽象类不能用final来声明; 抽象方法不能用private修饰 抽象类实则是定义了一个规范 abstract修饰的抽象方法没有方法体; 抽象类不能被直接实例化,但有构造方法 子类如果不是抽象类,则子类必须重写抽象类中的全部抽象方法。 abstract修饰符和final修饰符不能一起使用。
二:内部类
1:类的成员:
字段、方法、成员类/接口
2:成员类(内部类)
在类的里面声明的类为成员类, 可以被继承
定义一个内部类:创建对象,以及成员的调用
public static void main(String[] args) { /* 创建内部类对象的格式 外部类名.内部类名 对象名 = new 外部对象().new 内部对象(); */ Outer.Innter i = new Outer().new Innter(); //创建对象 System.out.println(i.num); //调用里面的成员 i.show(); //调用里面的方法。 } } class Outer{ class Innter{ int num = 10; public void show(){ System.out.println("Inner .. show"); } }
3:外部类和内部类的访问修饰符
外部类的访问修饰符只能是: public / package-access
成员类的访问修饰符可以是所有的访问修饰符
可以使用 final static abstract 等修饰符修饰成员类
4:创建对象的时候如何使用:
(1)成员内部类
内部类可以直接使用外部类中的成员(包括私有的)。
外部类要访问内部类的成员,必须创建对象。
public static void main(String[] args) { /* 创建内部类对象的格式 外部类名.内部类名 对象名 = new 外部对象().new 内部对象(); */ Outer.Innter i = new Outer().new Innter(); //创建对象 System.out.println(i.num); //调用里面的成员 i.show(); //调用里面的方法。 } } class Outer{ int a = 10; class Innter{ int num = 10; public void show(){ System.out.println("Inner .. show"); //内部类访问外部成员可以直接访问,包括私有 System.out.println(a); } }
(3)static 成员类
使用 类名. 调用. 使用 new 外部类.内部类();
A.B b = new A.B(); //new A.B();
(4)实例成员类
使用外部类的对象来调用. 使用 对象.new 内部类();
public static void main(String[] args) { //外部类 A a = new A(); //使用实例成员类 A.C c = a.new C(); // 等同于 new A().new C(); A.C c1 = new A().new C();//依赖于外部类的对象,先实例化外部类,在实例化内部类 }
在实例成员类中可以使用 外部类.this 表示外部类对象 (实例成员类是由外部类对象创建的)
成员类中的 this 表示的是成员类
外部类可以直接调用成员类的静态成员,实例成员需要创建成员类的对象来调用
成员类属于类的成员,所以可以调用外部类的 private 成员
外部类可以访问成员类的 private 成员
(5)私有成员内部类:
如果一个成员内部类被private私有化。如果外部类想再次访问,就只能在内部类所在的外部类中直接创建对象进行访问。
public static void main(String[] args) { //Outer1.Inner1 oi = new Outer().new Innter1(); //错误原因是因为Innner1已经被私有化了。 Outer1 o = new Outer1(); o.method(); } } class Outer1{ private class Inner1{ //没报错说明成员内部类是可以被private修饰的 public void show(){ System.out.println("inner .. show"); } } public void method(){ Inner1 i = new Inner1(); //在自己的类里面调用没问题。 i.show(); }
(6)静态成员内部类的创建格式:
(外部类名.内部类名 对象名 = new 外部类名.内部类名() );
public static void main(String[] args) { //创建格式:外部类名.内部类名 对象名 = new 外部类名.内部类名(); Outer2.Inner2 oi = new Outer2.Inner2(); oi.show(); Outer2.Inner2.method(); //调用静态内部类的静态方法 } } class Outer2{ static class Inner2{ public void show(){ System.out.println("inner ... show"); } public static void method(){ //静态内部类 System.out.println("method"); } }
5:内部类和外部类的区别
访问修饰符: 外部类只能有两种访问权限: public 以及 package-access 内部类可以有四种访问权限: public / protected / package-access / private static 修饰: 外部类不可以使用 static 修饰类,内部类可以 使用:外部类可以直接被使用,内部类的使用则依赖于外部类
三:匿名类
1:定义
匿名类是没有明确的名称的类。
2:格式
new类名或者是接口名(){ 重写方法; }
优势:
匿名内部类直接实现了接口,重写方法,创建了实现类对象,调用方法步骤都完成了。
3:注意事项
匿名类不能使用修饰符,在方法的内部,对外隐藏。不能是 static ,隐式 final类。
匿名类没有类名,没有构造方法。
匿名类不能定义接口,不能定义静态块,静态方法,静态变量
匿名类可以访问类中的成员,不能访问方法中的变量,除非是 final 的。
匿名类一般是实现接口、继承抽象类,实现了重写。相当于实现、继承了这个接口/类。
public abstract class Pet { public abstract void cry(); } //匿名类 Pet p = new Pet() { @Override public void cry() { System.out.println("喵 喵 喵"); } }; //后面还可以调用方法 //等同于 public class 类名 extends Pet{ @Override public void cry() { System.out.println("喵 喵 喵"); } }