面向对象基础（二）
1. 内部类：
- 普通内部类 ：直接将一个类的定义放在另外一个类的类体中。
- 静态内部类 ：使用static关键字修饰的内部类，隶属于类层级。
- 局部内部类 ：直接将一个类的定义放在方法体的内部时。
- 匿名内部类 ：就是指没有名字的内部类。
1. 普通内部类
-
语法：
访问修饰符 class 外部类的类名 { 访问修饰符 class 内部类的类名 { 内部类的类体; } } -
使用方式：
-
普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。
-
普通内部类和普通类一样可以使用final或者abstract关键字修饰。 多个内部类之间可以继承。
-
普通内部类还可以使用private或protected关键字进行修饰。 用private修饰外部类就无法访问，只能在本类访问。
-
普通内部类需要使用外部类对象来创建对象。首先要创建外部类对象，然后才能创建内部类对象。
外部类名.内部类对象名 = 外部类对象名.new 内部类名(); -
如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字，访问外部类同名变量，外部类名.this.变量名
/** * 编程实现普通内部类的定义和使用 */ public class NormalOuter { private int cnt = 1; // 定义普通内部类，隶属于外部类的成员，并且是对象层级 /*private*/public /*final*/ class NormalInner { private int ia = 2; private int cnt = 3; public NormalInner() { System.out.println("普通内部类的构造方法体执行到了！"); } public void show() { System.out.println("外部类中变量cnt的数值为：" + cnt); // 1 System.out.println("ia = " + ia); // 2 } public void show2(int cnt) { System.out.println("形参变量cnt = " + cnt); // 局部优先原则 4 System.out.println("内部类中cnt = " + this.cnt); // 3 System.out.println("外部类中cnt = " + NormalOuter.this.cnt); // 1 } } }public class NormalOuterTest { public static void main(String[] args) { // 1.声明NormalOuter类型的引用指向该类型的对象 NormalOuter no = new NormalOuter(); // 2.声明NormalOuter类中内部类的引用指向内部类的对象 NormalOuter.NormalInner ni = no.new NormalInner(); // 调用内部类中的show方法 ni.show(); System.out.println("---------------------------------------------"); ni.show2(4); } }
-
2. 静态内部类
-
语法：
访问修饰符 class 外部类的类名 { 访问修饰符 static class 内部类的类名 { 内部类的类体; } } -
使用方式：
-
静态内部类不能直接访问外部类的非静态成员。
-
静态内部类可以直接创建对象。
-
如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问。
/** * 实现静态内部类的定义和使用 */ public class StaticOuter { private int cnt = 1; // 隶属于对象层级 private static int snt = 2; // 隶属于类层级 public /*static*/ void show() { System.out.println("外部类的show方法就是这里！"); } /** * 定义静态内部类 有static关键字修饰隶属于类层级 */ public static class StaticInner { private int ia = 3; private static int snt = 4; public StaticInner() { System.out.println("静态内部类的构造方法哦！"); } public void show() { System.out.println("ia = " + ia); // 3 System.out.println("外部类中的snt = " + snt); // 2 //System.out.println("外部类的cnt = " + cnt); // Error:静态上下文中不能访问非静态的成员，因此此时可能还没有创建对象 } public void show2(int snt) { // 就近原则 System.out.println("snt = " + snt); // 5 System.out.println("内部类中的成员snt = " + StaticInner.snt); // 4 System.out.println("外部类中的成员snt = " + StaticOuter.snt); // 2 //StaticOuter.show(); new StaticOuter().show(); } } }public class StaticOuterTest { public static void main(String[] args) { // 1.声明StaticInner类型的引用指向该类型的对象 StaticOuter.StaticInner si = new StaticOuter.StaticInner(); // 2.调用show方法进行测试 si.show(); System.out.println("---------------------------------------------"); si.show2(5); } } -
3. 局部内部类（方法中）
-
语法：
访问修饰符 class 外部类的类名 { 访问修饰符 返回值类型 成员方法名（形参列表） { //不能有访问修饰符 class 内部类的类名 { 内部类的类体; } } } -
使用方式：
- 局部内部类只能在该方法的内部可以使用。 局部内部类可以在方法体内部直接创建对象。
- 局部内部类不能使用访问控制符和static关键字修饰符。
- 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
/** * 编程实现局部内部类的定义和使用 */ public class AreaOuter { private int cnt = 1; public void show() { // 定义一个局部变量进行测试，从Java8开始默认理解为final关键字修饰的变量 // 虽然可以省略final关键字，但建议还是加上 final int ic = 4; // 定义局部内部类，只在当前方法体的内部好使 拷贝一份 class AreaInner { private int ia = 2; public AreaInner() { System.out.println("局部内部类的构造方法！"); } public void test() { int ib = 3; System.out.println("ia = " + ia); // 2 System.out.println("cnt = " + cnt); // 1 //ic = 5; Error System.out.println("ic = " + ic); // 4 } } // 声明局部内部类的引用指向局部内部类的对象 AreaInner ai = new AreaInner(); ai.test(); } }
4. 匿名内部类
-
回调模式：回调模式是指——如果一个方法的参数是接口类型，则在调用该方法时， 需要创建并传递一个实现此接口类型的对象；而该方法在运行时会调用到参数对象中所实现的方法（接口中定义的）。
-
当接口/类类型的引用作为方法的形参时，实参的传递方式有两种：
- 自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递；
- 使用上述匿名内部类的语法格式得到接口/类类型的引用即可；
-
语法：
接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
public interface AnonymousInterface { // 自定义抽象方法 public abstract void show(); }public class AnonymousInterfaceImpl implements AnonymousInterface { @Override public void show() { System.out.println("这里是接口的实现类！"); } }public class AnonymousInterfaceTest { // 假设已有下面的方法，请问如何调用下面的方法？ // AnonymousInterface ai = new AnonymousInterfaceImpl(); // 接口类型的引用指向实现类型的对象，形成了多态 public static void test(AnonymousInterface ai) { // 编译阶段调用父类版本，运行调用实现类重写的版本 ai.show(); } public static void main(String[] args) { //AnonymousInterfaceTest.test(new AnonymousInterface()); // Error:接口不能实例化 AnonymousInterfaceTest.test(new AnonymousInterfaceImpl()); System.out.println("---------------------------------------------------------------"); // 使用匿名内部类的语法格式来得到接口类型的引用，格式为：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 }; AnonymousInterface ait = new AnonymousInterface() { @Override public void show() { System.out.println("匿名内部类"); } }; // 从Java8开始提出新特性lamda表达式可以简化上述代码，格式为：(参数列表) -> {方法体} AnonymousInterface ait2 = () -> System.out.println("lamda表达式"); AnonymousInterfaceTest.test(ait2); } }
2. 枚举（特殊的类）
-
定义:使用public static final表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。
-
枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰，因此采用枚举类型.的方式调用。
-
枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默 认也是私有的。所以枚举类不可以new对象,使用时直接枚举类.成员变量即可
/** * 编程实现所有方向的枚举，所有的方向：向上、向下、向左、向右 枚举类型要求所有枚举值必须放在枚举类型的最前面 */ public enum DirectionEnum implements DirectionInterface { UP("向上")，DOWN("向下"),LEFT("向左"),RIGHT("向右"); private final String desc; //用于描述方向字符串的成员变量 // 2.声明本类类型的引用指向本类类型的对象 public static final Direction UP = new Direction("向上"); public static final Direction DOWN = new Direction("向下"); public static final Direction LEFT = new Direction("向左"); public static final Direction RIGHT = new Direction("向右"); // 通过构造方法实现成员变量的初始化，更加灵活 // 1.私有化构造方法，此时该构造方法只能在本类的内部使用 private DirectionEnum(String desc) { this.desc = desc; } // 通过公有的get方法可以在本类的外部访问该类成员变量的数值 public String getDesc() { return desc; } }
-
-
Enum类常用方法
-
所有的枚举类都继承自java.lang.Enum类，常用方法如下：
/** * 编程实现方向枚举类的测试，调用从Enum类中继承下来的方法 * 名称是变量名,对象是变量值 */ public class DirectionEnumTest { public static void main(String[] args) { // 1.获取DirectionEnum类型中所有的枚举对象 DirectionEnum[] arr = DirectionEnum.values(); // 2.打印每个枚举对象在枚举类型中的名称和索引位置 for (int i = 0; i < arr.length; i++) { System.out.println("获取到的枚举对象名称是：" + arr[i].toString()); System.out.println("获取到的枚举对象对应的索引位置是：" + arr[i].ordinal()); // 和数组一样下标从0开始 } System.out.println("---------------------------------------------------------------"); // 3.根据参数指定的字符串得到枚举类型的对象，也就是将字符串转换为对象 //DirectionEnum de = DirectionEnum.valueOf("向下"); // 编译ok，运行发生IllegalArgumentException非法参数异常 DirectionEnum de = DirectionEnum.valueOf("DOWN"); //DirectionEnum de = DirectionEnum.valueOf("UP LEFT"); // 要求字符串名称必须在枚举对象中存在 //System.out.println("转换出来的枚举对象名称是：" + de.toString()); System.out.println("转换出来的枚举对象名称是：" + de); // 当打印引用变量时，会自动调用toString方法 System.out.println("---------------------------------------------------------------"); // 4.使用获取到的枚举对象与枚举类中已有的对象比较先后顺序 for(int i = 0; i < arr.length; i++) { // 当调用对象在参数对象之后时，获取到的比较结果为 正数 // 当调用对象在参数对象相同位置时，则获取到的比较结果为 零 // 当调用对象在参数对象之前时，则获取到的比较结果为 负数 System.out.println("调用对象与数组中对象比较的先后顺序结果是：" + de.compareTo(arr[i])); } System.out.println("---------------------------------------------------------------"); // 5.使用数组中每个DirectionEnum对象都去调用show方法测试 for (int i = 0; i < arr.length; i++) { arr[i].show(); } } }
-
-
枚举类实现接口的方式
-
枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写一个，或者每个对象都重写。
public interface DirectionInterface { // 自定义抽象方法 public abstract void show(); }/** * 编程实现所有方向的枚举，所有的方向：向上、向下、向左、向右 枚举类型要求所有枚举值必须放在枚举类型的最前面 */ public enum DirectionEnum implements DirectionInterface { UP("向上")，DOWN("向下"),LEFT("向左"),RIGHT("向右"); private final String desc; //用于描述方向字符串的成员变量 // 2.声明本类类型的引用指向本类类型的对象 // 匿名内部类的语法格式：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 }; // 完整写法,public static final Direction UP = new Direction("向上") { 方法的重写 }; UP("向上") { @Override public void show() { System.out.println("贪吃蛇向上移动了一下！"); } }, DOWN("向下") { @Override public void show() { System.out.println("贪吃蛇向下移动了一下！"); } }, LEFT("向左") { @Override public void show() { System.out.println("左移了一下！"); } }, RIGHT("向右") { @Override public void show() { System.out.println("右移了一下！"); } }; private final String desc; // 用于描述方向字符串的成员变量 // 通过构造方法实现成员变量的初始化，更加灵活 // 1.私有化构造方法，此时该构造方法只能在本类的内部使用 private DirectionEnum(String desc) { this.desc = desc; } // 通过公有的get方法可以在本类的外部访问该类成员变量的数值 public String getDesc() { return desc; } // 整个枚举类型只重写一次，所有对象调用同一个 /*@Override public void show() { System.out.println("现在可以实现接口中抽象方法的重写了！"); }*/ }
-
3. 注解（特殊的接口）
-
概念: 注解（Annotation）又叫标注，是从Java5开始增加的一种引用数据类型。注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、 以及运行时执行指定的处理。
-
语法格式：
访问修饰符 @interface 注解名称 { 注解成员; }- 自定义注解自动继承java.lang.annotation.Annotation接口。
- 通过@注解名称的方式可以修饰包、类、 成员方法、成员变量、构造方 法、参数、局部变量的声明等
-
使用方式：
-
注解体中只有成员变量没有成员方法，而注解的成员变量以“无形参的方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。
-
如果注解只有一个参数成员，建议使用参数名为value，而类型只能是八种基本数据类型、String类型、Class类型（指类名.class）、enum类型及Annotation类型。
-
注解后如果不传参数，可以在注解中用default进行变量的初始化。
import java.lang.annotation.*; // 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解 public @interface MyAnnotation { //public Direction value(); // 声明一个String类型的成员变量，名字为value 类型有要求 public String value() default "123"; // 声明一个String类型的成员变量，名字为value public String value2(); }// 表示将标签MyAnnotation贴在Person类的代码中，使用注解时采用 成员参数名 = 成员参数值, ... //@MyAnnotation(value = "hello", value2 = "world") @MyAnnotation(value2 = "world") public class Person { private String name; }
-
-
元注解
-
概念：元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但 是它能够应用到其它的注解上面。 元注解主要有 @Retention、@Documented、@Target、@Inherited、 @Repeatable。
-
@retention应用到一个注解上用于说明该注解的的生命周期，取值如下：
- RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时 它将被丢弃忽视。
- RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加 载到 JVM 中，默认方式。
- RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载 进入到 JVM 中，所以在程序运行时可以获取到它们。
-
使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一 个和源代码配套的API帮助文档，而该工具抽取时默认不包括注解内容。 在idea中菜单栏Tools->Generate JavaDoc使用javadoc工具
- @Documented用于指定被该注解将被javadoc工具提取成文档。
- 定义为@Documented的注解必须设置Retention值为RUNTIME
-
@Target用于指定被修饰的注解能用于哪些元素的修饰，取值如下：
-
@Inherited并不是说注解本身可以继承，而是说如果一个超类被该注解标记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继承超类的注解。
-
import java.lang.annotation.*; //@Retention(RetentionPolicy.SOURCE) // 表示下面的注解在源代码中有效 //@Retention(RetentionPolicy.CLASS) // 表示下面的注解在字节码文件中有效，默认方式 @Retention(RetentionPolicy.RUNTIME) // 表示下面的注解在运行时有效 @Documented // 表示下面的注解信息可以被javadoc工具提取到API文档中，很少使用 // 表示下面的注解可以用于类型、构造方法、成员变量、成员方法、参数 的修饰 @Target({ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER}) @Inherited // 表示下面的注解所修饰的类中的注解使用可以被子类继承 // 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解 public @interface MyAnnotation { //public Direction value(); // 声明一个String类型的成员变量，名字为value 类型有要求 public String value() default "123"; // 声明一个String类型的成员变量，名字为value public String value2(); } -
@Repeatable表示自然可重复的含义，从Java8开始增加的新特性。 从Java8开始对元注解@Target的参数类型ElementType枚举值增加了两个：
- 其中ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明 语句中，如：泛型。
- 其中ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
import java.lang.annotation.ElementType; import java.lang.annotation.Target; /** * 自定义注解里面可以描述多种角色 */ @Target(ElementType.TYPE_USE) public @interface ManTypes { ManType[] value(); } -
import java.lang.annotation.ElementType; import java.lang.annotation.Repeatable; import java.lang.annotation.Target; /** * 自定义注解用于描述任务的角色 */ @Repeatable(value = ManTypes.class) @Target(ElementType.TYPE_USE) public @interface ManType { String value() default ""; } -
@ManType(value = "职工") @ManType(value = "超人") //@ManTypes({@ManType(value = "职工"), @ManType(value = "超人")}) // 在Java8以前处理多个注解的方式 public class Man { @Deprecated // 表示该方法已经过时，不建议使用 public void show() { System.out.println("这个方法马上过时了！"); } public static void main(String[] args) { int ia = 97; char c1 = (@ManType char) ia; } } -
public class ManTest { public static void main(String[] args) { Man man = new Man(); man.show(); } } -
常见的预制注解
- 预制注解就是Java语言自身提供的注解，具体如下：
-
183
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
