JavaSE（11）：特殊类

最新推荐文章于 2023-12-25 21:09:28 发布
最新推荐文章于 2023-12-25 21:09:28 发布
阅读量795 收藏
点赞数
分类专栏： JavaSE学习笔记 # Java面向对象编程 文章标签： java javase 内部类 枚举类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37973227/article/details/119323483
版权

文章目录

1、内部类

1.1 内部类的概念

1.1.1 基本概念

  • 类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静态代码块、内部类。
  • 当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）。

1.1.2 内部类的实际作用

  • 当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法。

1.1.3 内部类的分类

  • 普通内部类 - 直接将一个类的定义放在另外一个类的类体中。
  • 静态内部类 - 使用static关键字修饰的内部类，隶属于类层级。
  • 局部内部类 - 直接将一个类的定义放在方法体的内部时。
  • 匿名内部类 - 就是指没有名字的内部类。

1.2 普通内部类

  • 也叫成员内部类。

1.2.1 普通内部类的定义

  • 语法格式：
访问修饰符 class 外部类的类名 {
	访问修饰符 class 内部类的类名 {
		内部类的类体;
	}
}
  • 如：
public class NormalOuter {
    private int cnt = 1;

    // 定义普通内部类，隶属于外部类的成员，并且是对象层级
    public class NormalInner {
        private int cnt = 2;

        public NormalInner() {
            System.out.println("普通内部类的构造方法");
        }

        public void show(int cnt) {
            System.out.println("形参变量cnt = " + cnt);  // 局部优先原则
            System.out.println("内部类中cnt = " + this.cnt);
            System.out.println("外部类中cnt = " + NormalOuter.this.cnt);
        }
    }
}

// 测试调用普通内部类NormalInner中的show方法
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(3);
    }
}
/*
运行结果：
普通内部类的构造方法
形参变量cnt = 3
内部类中cnt = 2
外部类中cnt = 1
*/

1.2.2 普通内部类的使用方式

  • 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。
  • 普通内部类和普通类一样可以使用final或者abstract关键字修饰。
  • 普通内部类还可以使用private或protected关键字进行修饰。
  • 普通内部类需要使用外部类对象来创建对象。
  • 如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字。

1.3 静态内部类

1.3.1 静态内部类的定义

  • 语法格式：
访问修饰符 class 外部类的类名 {
	访问修饰符 static class 内部类的类名 {
		内部类的类体;
	}
}
  • 如：
public class StaticOuter {
    private static int snt = 2;      // 隶属于类层级

    public void test() {
        System.out.println("外部类中的test方法！");
    }

    // 定义静态内部类  有static关键字修饰类属于类层级
    public static class StaticInner {
        private static int snt = 4;

        public StaticInner() {
            System.out.println("静态内部类的构造方法");
        }

        public void show(int snt) {    // 就近原则
            System.out.println("形参变量snt = " + snt);
            System.out.println("内部类中的成员snt = " + StaticInner.snt);
            System.out.println("外部类中的成员snt = " + StaticOuter.snt);
            // 静态内部类不能直接访问外部类的非静态成员，需要创建对象才能访问
            new StaticOuter().test();
        }
    }
}

// 测试调用静态内部类StaticInner中的show方法
public class StaticOuterTest {

    public static void main(String[] args) {

        // 1.声明StaticInner类型的引用指向该类型的对象
        StaticOuter.StaticInner si = new StaticOuter.StaticInner();
        // 2.调用show方法进行测试
        si.show(6);
    }
}
/*
运行结果：
静态内部类的构造方法
形参变量snt = 6
内部类中的成员snt = 4
外部类中的成员snt = 2
外部类中的test方法！
*/

1.3.2 静态内部类的使用方式

  • 静态内部类不能直接访问外部类的非静态成员，需要创建外部类的对象才能访问。
  • 静态内部类可以直接创建对象。
  • 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问。

1.4 局部内部类

  • 也叫方法内部类。

1.4.1 局部内部类的定义

  • 语法格式：
访问修饰符 class 外部类的类名 {
	访问修饰符 返回值类型 方法成员名(形参列表) {
		class 内部类的类名 {
			内部类的类体;
		}
	}
}
  • 如：
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() {
                System.out.println("ia = " + ia);
                System.out.println("cnt = " + cnt);
                System.out.println("ic = " + ic);
            }
        }

        // 声明局部内部类的引用指向局部内部类的对象
        AreaInner ai = new AreaInner();
        ai.test();
    }
}

// 测试通过调用show方法实现局部内部类AreaInner的使用
public class AreaOuterTest {

    public static void main(String[] args) {

        // 1.声明外部类的引用指向外部类的对象
        AreaOuter ao = new AreaOuter();
        // 2.通过show方法的调用实现局部内部类的定义和使用
        ao.show();
    }
}

1.4.2 局部内部类的使用方式

  • 局部内部类只能在该方法的内部可以使用。
  • 局部内部类可以在方法体内部直接创建对象。
  • 局部内部类不能使用访问控制符和static关键字修饰符。
  • 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。

1.5 回调模式

  • 回调模式是指——如果一个方法的参数是接口类型，则在调用该方法时，需要创建并传递一个实现此接口类型的对象；而该方法在运行时会调用到参数对象中所实现的方法（接口中定义的）。
  • 例如：
// 自定义接口
public interface AnonymousInterface {

	// 自定义抽象方法
    public abstract void show();
}

// 接口AnonymousInterface的一个实现类AnonymousInterfaceImpl
public class AnonymousInterfaceImpl implements AnonymousInterface {
	// 重写接口AnonymousInterface中的抽象方法show
    @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) {

        // 接口不能实例化，调用test方法时，将实现类的对象作为实参
        AnonymousInterfaceTest.test(new AnonymousInterfaceImpl());
    }
}

1.6 匿名内部类

1.6.1 匿名内部类的定义

  • 语法格式：
接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };

1.6.2 匿名内部类的使用

  • 当接口/类类型的引用作为方法的形参时，实参的传递方式有两种：
    • 一是自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递。比如上面所述的回调模式。
    • 二是使用上述匿名内部类的语法格式得到接口/类类型的引用即可。这种方式相比第一种，省去了创建实现类/继承类的步骤，在开发中使用较多。
public class AnonymousInterfaceTest {

	// 将接口类型的引用作为test方法的形参
    public static void test(AnonymousInterface ai) {
        ai.show();
    }

    public static void main(String[] args) {
		
		// 使用匿名内部类的语法格式来得到接口类型的引用
        // 格式为：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
        AnonymousInterface ait = new AnonymousInterface() {
        	// 在匿名内部类中重写接口中的抽象方法show
            @Override
            public void show() {
                System.out.println("这里是匿名内部类！");
            }
        };
        // 调用test方法，将上面得到的接口类型的引用作为实参传递
        AnonymousInterfaceTest.test(ait);
    }
}
  • 从Java8开始提出新特性 lamda表达式 可以简化上述匿名内部类的代码，格式为：
(参数列表) -> {方法体}

AnonymousInterface ait2 = () -> System.out.println("lamda表达式！");
AnonymousInterfaceTest.test(ait2);

2、枚举

2.1 枚举的基本概念

  • 一年中的所有季节：春季、夏季、秋季、冬季。
  • 所有的性别：男、女。
  • 键盘上的所有方向按键：向上、向下、向左、向右。
  • 在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事物的所有值都可以一一列举出来，而这个列举出来的类型就叫做枚举类型。

2.2 枚举的定义

  • 使用public static final表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。
  • 枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰，因此采用枚举类型.的方式调用。
  • 枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默认也是私有的。
/**
 * 编程实现所有方向的枚举，所有方向：向上、向下、向左、向右
 */
public enum DirectionEnum {
    // 2.声明本类类型的引用指向本类类型的对象
    // 下面的代码相当于 public static final Direction UP = new Direction("向上")
    // 枚举类型要求所有枚举值必须放在枚举类型的最前面
    UP("向上"), DOWN("向下"), LEFT("向左"), RIGHT("向右");

    private final String desc;  // 用于描述方向字符串的成员变量

    // 通过构造方法实现成员变量的初始化，更加灵活
    // 1.私有化构造方法，此时构造方法只能在本类的内部使用
    private DirectionEnum(String desc) {
        this.desc = desc;
    }

    // 通过公有的get方法可以在本类的外部访问该类成员变量的数值
    public String getDesc() {
        return desc;
    }
}

2.3 Enum类的概念和方法

  • 所有的枚举类都继承自java.lang.Enum类，常用方法如下：
方法作用
static T[ ] values()返回当前枚举类中的所有对象
String toString()返回当前枚举类对象的名称
int ordinal()获取枚举对象在枚举类中的索引位置
static T valueOf(String str)将参数指定的字符串名转为当前枚举类的对象
int compareTo​(E o)比较两个枚举对象在定义时的顺序
  • 打印引用变量时，自动调用toString方法。下面两行打印语句的效果是一样的：
// 访问得到的枚举对象，赋值给DirectionEnum类型的引用变量
DirectionEnum de = DirectionEnum.DOWN;
System.out.println("枚举对象名称是：" + de.toString());
System.out.println("枚举对象名称是：" + de);  // 自动调用toString方法
  • ordinal()获取到的索引位置是枚举对象在枚举类中创建时的位置，和数组下标一样从0开始。
  • valueOf()参数指定的字符串名称必须在枚举对象中存在，否则会出现编译通过，但运行时发生IllegalArgumentException（非法参数异常）。
  • compareTo()方法：
    • 当调用对象在参数对象之后时，获取到的比较结果为 正数
    • 当调用对象在参数对象相同位置时，获取到的比较结果为 零
    • 当调用对象在参数对象之前时，获取到的比较结果为 负数

2.4 枚举类实现接口的方式

  • 枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写一个，或者每个对象都重写。
// 枚举类实现接口，重写一个抽象方法
public enum DirectionEnum implements DirectionInterface {
    
    UP("向上"), DOWN("向下"), LEFT("向左"), RIGHT("向右");

    private final String desc;

    private DirectionEnum(String desc) {
        this.desc = desc;
    }

    public String getDesc() {
        return desc;
    }

	@Override
    public void show() {
        System.out.println("重写接口中的抽象方法");
    }
}

// // 枚举类实现接口，每个枚举对象都重写自己独有的方法
public enum DirectionEnum implements DirectionInterface{
    
    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;

    private DirectionEnum(String desc) {
        this.desc = desc;
    }

    public String getDesc() {
        return desc;
    }
}

3、注解

3.1 注解的概念

3.1.1 注解的基本概念

  • 注解（Annotation）又叫标注，是从Java5开始增加的一种引用数据类型。
  • 注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、以及运行时执行指定的处理。

3.1.2 注解的定义

  • 语法格式：
访问修饰符 @interface 注解名称 {
	注解成员;
}
  • 如：
public @interface MyAnnotation {
    String value();
}
  • 自定义注解时，可以使用default关键字给注解体中的成员变量一个初始值。
public @interface MyAnnotation {
    String value() default "Hello";
}
  • 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解。
  • 自定义注解自动继承java.lang.annotation.Annotation接口。
  • 通过 @注解名称 的方式可以修饰包、类、 成员方法、成员变量、构造方法、参数、局部变量的声明等。

3.1.3 注解的使用方式

  • 注解体中只有成员变量没有成员方法，而注解的成员变量以“无形参的方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。
  • 如果注解只有一个参数成员，建议使用参数名为value，而类型只能是八种基本数据类型、String类型、Class类型、enum类型及Annotation类型。

3.2 元注解

3.2.1 元注解的概念

  • 元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。
  • 元注解主要有 @Retention、@Documented、@Target、@Inherited、@Repeatable。

3.2.2 元注解@Retention

  • @Retention 应用到一个注解上用于说明该注解的的生命周期，取值如下：
    • RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
    • RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中，默认方式。
    • RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。

3.2.3 元注解@Documented

  • 使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档，而该工具抽取时默认不包括注解内容。
  • @Documented用于指定被该注解将被javadoc工具提取成文档。
  • 定义为@Documented的注解必须设置Retention值为RUNTIME。

3.2.4 元注解@Target

  • @Target用于指定被修饰的注解能用于哪些元素的修饰，取值如下：
@Target的取值作用
ElementType.ANNOTATION_TYPE可以给一个注解进行注解
ElementType.CONSTRUCTOR可以给构造方法进行注解
ElementType.FIELD可以给属性进行注解
ElementType.LOCAL_VARIABLE可以给局部变量进行注解
ElementType.METHOD可以给方法进行注解
ElementType.PACKAGE可以给一个包进行注解
ElementType.PARAMETER可以给一个方法内的参数进行注解
ElementType.TYPE可以给类型进行注解，比如类、接口、枚举
  • @Target可以取一个值，也可以取多个值。取哪些值表明被修饰的注解只能作用于哪些对应的元素。如下面的代码，表示自定义的MyAnnotation注解只能用于类型、构造方法、成员变量的修饰，若用于修饰除上述三种元素以外的元素（如成员方法、方法内的参数等），则代码会编译出错。
@Target({ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD})
public @interface MyAnnotation {
    public String value() default "123";
    public String value2();
}

3.2.5 元注解@Inherited

  • @Inherited并不是说注解本身可以继承，而是说如果一个超类被@Inherited标记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继承超类的注解。

3.2.6 元注解@Repeatable

  • @Repeatable表示自然可重复的含义，从Java8开始增加的新特性。
  • 从Java8开始对元注解@Target的参数类型ElementType枚举值增加了两个：
    • 其中ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中，如：泛型。
    • 其中ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
/**
 * 自定义注解用于描述任务的角色
 * 被@Repeatable注解后，@ManType就可以重复修饰同一元素
 */
@Repeatable(value = ManTypes.class)
public @interface ManType {
    String value() default "";
}

/**
 * 自定义注解里面可以描述多种角色
 */
@Target(ElementType.TYPE_USE)
public @interface ManTypes {
    ManType[] value();
}

/**
 * 这里Man类可以被@ManType取不同的值重复注解
 */
@ManType(value = "职工")
@ManType(value = "超人")
public class Man {
}

3.3 预制注解

  • 预制注解就是Java语言自身提供的注解，常见的预制注解如下：
预制注解作用
@author标明开发该类模块的作者，多个作者之间使用,分割
@version标明该类模块的版本
@see参考转向，也就是相关主题
@since从哪个版本开始增加的
@param对方法中某参数的说明，如果没有参数就不能写
@return对方法返回值的说明，如果方法的返回值类型是void就不能写
@exception对方法可能抛出的异常进行说明
@Override限定重写父类方法, 该注解只能用于方法
@Deprecated用于表示所修饰的元素(类, 方法等)已过时
@SuppressWarnings抑制编译器警告
观于海者难为水
关注
专栏目录
JavaSE入门：数组
雙馬程序猿
08-02 232
JavaSE入门：数组：1.数组的定义、2.数组的声明和创建、3.内存分析、4.数组的基本特点、5.数组的使用、6.二维与多维数组、7.Arrays类、8.冒泡排序、9.稀疏数组、10.练习题
JavaSE：String类
weixin_55547460的博客
06-01 860
String类型 1.字符串构造方法 常用的有三种 public static void main(String[] args) { // 使用常量串构造 String s1 = "hello bit"; System.out.println(s1); // 直接newString对象 String s2 = new String("hello bit"); System.out.println(s1); // 使用字符数组进行构造 char[] array = {'h','e','l','l','o','
Java中枚举类型的一种使用方式
08-18
主要介绍了Java中枚举类型的一种使用方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java中的内部类、枚举
最新发布
Mafia的博客
12-25 1388
一种特殊的局部内部类；所谓匿名：指的是不需要为这个类声明名字特点：把这个匿名内部类编译成一个子类，然后会立即创建一个类对象出来作用：用于更方便的创建一个子类对象左边是Java类代码，右边是编译后的class文件是一种特殊的类：是一种固定数量的类枚举类中的第一行，只能写一些合法的标识符（名称），多个名称用逗号隔开；这些名称，本质是常量，每个常量都会记住枚举类的一个对象。反编译可以看到。
Java学习-Day16（内部类、枚举、注解）
wanlaizhou的博客
04-19 309
内部类 基本介绍 一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类，嵌套其他类的类称为外部类，是我们类的第五大成员。 内部类的最大特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。（难且重要，底层源码有大量内部类） 基本语法 class Outer{ //外部类 class Inner{ //内部类 } } class Other{ //外部其他类 } 内部类的分类 定义在外部类的局部位置上（比如方法内）： 局部内部类（
深入Java 1.5枚举类型的内部
幽客独往
12-19 4516
    Java是一种面向对象的高级编程语言。它的出众之处就在于它的简洁。一个程序员所要做的就是创建类（Create Class）以及定义接口（Define Interface），如此而已。当然，这种简洁和优美是有代价的，比如失去了Enum这种广泛使用的数据类型就是一个不小的损失。在Java 1.5以前，程序员们不得不通过一些变通的方法来间接的解决这一问题。比如说，被普遍使用的整数枚举替代法和类型
Javase-内部类&枚举
吃土的柚的博客
04-24 567
内部类是类中的五大成分之一（成员变量、方法、构造器、内部类、代码块），如果一个类定义在另一个类的内部，这个类就是内部类。当一个类的内部，包含一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。比如：汽车、的内部有发动机，发动机是包含在汽车内部的一个完整事物，可以把发动机设计成内部类。内部类有四种形式，分别是成员内部类、静态内部类、局部内部类、匿名内部类。
8、JavaSE：常用类.pdf
04-24
Java SE（Standard Edition）是Java的一个重要版本，它包含了大量的常用类，这些类是Java开发中经常用到的基础工具和组件。在本系列文档中，我们将深入学习Java常用类的使用和原理，这些知识对于掌握Java高级特性至...
javase:我学习javaSE的笔记
03-14
14. **枚举（Enum）**：枚举是一种特殊的类，用于定义一组相关的值，通常用来表示有限的固定集合。 15. **注解（Annotation）**：注解是元数据，提供了一种安全的方式来将信息附加到代码中，编译器和JVM可以使用...
JavaSE进阶：多线程(三)
雙馬程序猿
08-26 300
JavaSE进阶:多线程(一)： 多线程(三)：5.线程通信、6.高级线程(线程池)、7、线程安全的集合
12.30学习Java的day12【内部类、注解】
weixin_45506970的博客
03-06 403
day12【内部类、注解】 今日内容 内部类 注解 学习目标 说出内部类的几种形式 能够声明静态内部类和非静态成员内部类 能够看懂和声明匿名内部类 能够使用系统预定义的三个基本注解 能够编写文档注释 能够使用JUnit框架的@Test注解 能够读懂元注解 第七章 面向对象基础–下（续） 7.4 内部类 7.4.1 概述 1、什么是内部类？ 将一个类A定义在另一个类B里面，里面...
java泛型，内部类，枚举类型
Bubble1210的博客
02-22 1898
（1）泛型 JDK1.5之后增加的新功能，泛型可以解决数据类型的安全性问题，他主要的原理，是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。 格式：访问权限 class 类名称{ 属性 方法} 泛型方法：访问权限 泛型标识 方法名称（泛型标识 参数名称）
Java进阶总结7——内部类、枚举
qq_41534115的博客
08-03 741
1.内部类  * 内部类：在类的内部定义一个类，可以看做类的成员  * 类的成员：字段、方法、类  * 内部类类型：  *         1.实例内部类  *         2.静态内部类  *         3.局部内部类  *         4.匿名内部类  1.1 实例内部类      * 实例内部类      *         位置：类中，方法外      *    ...
掌握Java内部类和枚举
大数据技术开发
06-29 635
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，类B则称为外部类。
Java枚举类
yu的博客
02-03 5096
Java的内部类详解（成员内部类、静态内部类、局部内部类、匿名内部类）
java内部类和枚举
爱喝星冰乐的博客
06-02 637
文章目录内部类与枚举1、内部类2、静态内部类3、局部内部类4、匿名内部类5、lambda表达式枚举1、简单定义枚举类型 内部类与枚举 1、内部类 内部类不可以独立创建，需要穿件外部类以后，使用外部类实例来创建内部类（static除外） 2、静态内部类 static 内部类可以不用创建外部类 3、局部内部类 通常是在一个方法中定义一个类。局部内部类不能使用public 或者定义private 等来限定，作用于仅限于作用域内。局部内部类对外部类不可见。 4、匿名内部类 语法： new SuperType (Pa
Java中的枚举类
m0_60438688的博客
03-17 1451
Java中的枚举类,深入理解，配合代码学习更轻松。枚举类的使用，枚举类的实现，枚举类的方法
Java面向对象（内部类）（枚举）（泛型）
Java和网络安全学习交流
08-14 368
/这里的其实指的就是类型变量，可以是一个，也可以是多个。public class 类名{
java类基础之枚举和内部类
qq_51178489的博客
07-08 343
package rejava2.内部类和枚举; //内部类可以在任何类中 public class TestClass_5 { public static void main(String[] args){ InnerClass.A innerDemo=new InnerClass().new A(); //或import InnerClass.A innerDemo.innerClassMethod(); face fa=new
JavaSE入门：类与对象探索
- **类（Class）**：类是面向对象编程中的蓝图，它定义了一组属性（数据成员）和行为（方法）。类是创建对象的模板。 - **对象（Object）**：对象是类的实例，它具有类定义的属性和行为。每个对象都可以有自己的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值