《JavaSE-第八章》-代码块与内部类

已于 2022-05-14 17:19:39 修改
阅读量657 收藏 17
点赞数 32
分类专栏： Java 文章标签： java 开发语言
于 2022-05-14 16:32:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60308100/article/details/124770074
版权

前言

本章介绍static成员,使用代码块初始化对象以及内部类。

博客主页：KC老衲爱尼姑的博客主页

博主的github，平常所写代码皆在于此

共勉：talk is cheap, show me the code

作者是爪哇岛的新手，水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！

文章目录

✈1.static成员

看过《射雕英雄传》的朋友都知道，陈玄风，陆乘风，梅超风都是桃花岛主黄药师的学生。那么我们如果想通过学生类去出创造出这三个人，我们是否需要将学生类中添加一个成员变量来记录他们的老师呢?答案是不用的。因为在类中成员变量，每个对象都会包含，成员变量是用来描述具体学生的信息。而在江湖中人人都知道他们的老师是黄老师，没必要自己在举个写着我的老师是黄药师的牌子告诉别人。既然这份信息是共享的，那么我们不需要所有的对象都储存一份信息，只需要将这份信息共享给所有的对象即可。在java中要实现共享可以使用static去修饰成员，被static修饰的成员，称之为静态成员，也被称为静态类，不属于具体的对象，属于类，是所有的对象所共享的。

✈1.1static修饰成员变量

桃花岛学生类


package Demo;

public class PeachBlossomIslandStudent {
   private String name;
   private String sex;
   private double height;
  public static final String  teacher="黄药师";
    public PeachBlossomIslandStudent() {
    }


    public PeachBlossomIslandStudent(String name, String sex, double height) {
        this.name = name;
        this.sex = sex;
        this.height = height;

    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", height=" + height +
                ",teacher="+ PeachBlossomIslandStudent.teacher+
                '}';
    }
}

学生测试类

package Demo;


public class PeachBlossomIslandStudentText {
    public static void main(String[] args) {
        PeachBlossomIslandStudent s=new PeachBlossomIslandStudent("陈玄风","男",1.7);
        PeachBlossomIslandStudent s2=new PeachBlossomIslandStudent("梅超风","女",1.70);
        PeachBlossomIslandStudent s3=new PeachBlossomIslandStudent("陆乘风","男",1.70);
        System.out.println(s);
        System.out.println(s2);
        System.out.println(s3);
    }
}

因为被static修饰的成员变量是共享的，同时也是可以修改的，但是上述陈玄风,梅超风,陆乘风一辈子只有一个老师，所以我们可以用final再次修饰静态成员，final意为最终的，是不可变的，它修饰的变量是能赋值一次。

✈1.2static修饰成员方法

sattic修饰的方法被成员静态方法

public class PeachBlossomIslandStudent {
   private String name;
   private String sex;
   private double height;
  public static final String  teacher="黄药师";

    public PeachBlossomIslandStudent() {
    }


    public PeachBlossomIslandStudent(String name, String sex, double height) {
        this.name = name;
        this.sex = sex;
        this.height = height;

    }



    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", height=" + height +
                ",teacher="+ PeachBlossomIslandStudent.teacher+
                '}';
    }
    //静态方法
    public static void flute(){
        System.out.println("碧海潮生曲");
    }

    public static void sword(){
        System.out.println("落英神剑掌");
    }
    //成员方法
    public void study(){
        System.out.println("好好学习");

    }

}

现在知道了如何使用static，那么如何访问被static修饰的成员呢？在java中被static修饰的成员是属于类的，而不是属于对象独有，所以我们一般是用类名.属性或者类型.方法名，来使用被static修饰的成员

使用static修饰的成员

代码示例

package Demo;

/**
 * truth:talk is cheap, show me the code
 *
 * @author KC萧寒
 * @description
 * @createDate: 2022-05-14 09:34
 */

public class PeachBlossomIslandStudentText {
    public static void main(String[] args) {
        PeachBlossomIslandStudent s=new PeachBlossomIslandStudent("陈玄风","男",1.7);
        PeachBlossomIslandStudent s2=new PeachBlossomIslandStudent("梅超风","女",1.70);
        PeachBlossomIslandStudent s3=new PeachBlossomIslandStudent("陆乘风","男",1.70);
        System.out.println(s);
        System.out.println(s2);
        System.out.println(s3);
        PeachBlossomIslandStudent.sword();
        PeachBlossomIslandStudent.flute();
        s.sword();//错误使用
        s.flute();//错误使用
    }
}

切记被static修饰的成员本质上属于类，但是它又是被所有对象所共享，所以可以通过对象的引用去访问。这种方式的访问是不建议使用，我们通常访问静态成员使用类名去访问。

静态方法中无法使用实例成员变量

静态方法

在这里插入图片描述

成员方法
在这里插入图片描述

对于静态的方法它属于类，不属于特定对象，所以它的形参列表中默认是没有this,没有this自然就不能使用成员变，而成员方法中的形参列表默认有this，这样我们才能调用当前类的成员。

✈1.3static成员内存解析图

解析此代码

package Demo;


public class PeachBlossomIslandStudent {
   private String name;
   private String sex;
   private double height;
  public static final String  teacher="黄药师";

    //静态方法
    public static void flute(){
        System.out.println("碧海潮生曲");
    }

    public static void sword(){
        System.out.println("落英神剑掌");
    }
    //成员方法
    public void study(){
        System.out.println("好好学习");

    }

    public static void main(String[] args) {
        PeachBlossomIslandStudent s=new PeachBlossomIslandStudent();
        s.name="陈玄风";
        s.sex="男";
        s.height=1.90;
        PeachBlossomIslandStudent s2=new PeachBlossomIslandStudent();
        s2.name="梅超风";
        s2.sex="女";
        s2.height=1.70;
    }
}

内存图

在这里插入图片描述

✈1.4static成员总结

成员变量特性

  1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
  2. 类变量存储在方法区当中
  3. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
  4. 可以通过对象的引用访问，也可以通过类名访问，建议使用类名访问

成员方法特性

  1. 是类的方法，不属于对象。
  2. 不能在静态方法中访问任何非静态成员变量
  3. 可以通过对象调用，也可以通过类名.

static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性

静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。

  1. 就地初始化 就地初始化指的是：在定义时直接给出初始值
 public static final String  teacher="黄药师";//就地初始化

接下来就来介绍代码块

✈2.代码块

代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

  1. 普通代码块
  2. 构造块
  3. 静态块
  4. 同步代码块(暂时不介绍)

✈2.1普通代码块

普通代码块：定义在方法中的代码块.

代码示例

public class Demo {
    public static void main(String[] args) {
        {
            int age=99;
            System.out.println(age);
        }
        age=9;
    }
}

代码块中的age是局部变量，大括号是它的作用域即使用范围，所以代码外的age是无法使用的。这个普通代码块基本不用。

✈2.2构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

代码示例

public class Demo {
    private int age;
    private String name;
    private String school;

    public Demo() {
        System.out.println("无参构造器初始化");
    }

    {
        System.out.println("构造块初始化");
        age = 12;
        name = "小白";
        school = "家里蹲";
    }

    public void show() {
        System.out.println("name: " + name + " age: " + age + " schoo: " + school);
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        d.show();
    }
}

运行结果

构造块初始化
无参初始化
name: 小白 age: 12 schoo: 家里蹲

结论：构造块的初始化早于构造器的。

✈2.3静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

代码示例

public class Demo {
    private   int age;
    private   String name;
    private static  String school;

    public Demo() {
        System.out.println("无参构造器初始化");
    }

   static {
        System.out.println("静态代码块初始化");
        school = "家里蹲";
    }

    {
        System.out.println("实例代码块初始化");
        age = 12;
        name = "小白";
    }

    public void show() {
        System.out.println("name: " + name + " age: " + age + " schoo: " + school);
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        d.show();
    }
}

运行结果

静态代码块初始化
实例代码块初始化
无参构造器初始化
name: 小白 age: 12 schoo: 家里蹲

✈2.4初始化顺序总结

package task;


public class LifeCycle {
    //静态属性
    private static String staticField = getStaticField();

    //静态代码块
    static {
        System.out.println(staticField);
        System.out.println("静态代码初始化");
    }

    //普通属性/成员属性
    private String field = getField();

    //普通方法块/实例代码块
    {
        System.out.println(field);
        System.out.println("实例代码块初始化");
    }

    //构造函数初始化
    public LifeCycle() {
        System.out.println("构造函数初始化");
    }

    public static String getStaticField() {
        String statiFiled = "静态属性初始化";
        return statiFiled;
    }

    public static String getField() {
        String filed = "普通属性初始化";
        return filed;
    }
    
    public static void main(String[] argc) {
        new LifeCycle();
    }
}

运行结果

静态属性初始化
静态代码初始化
普通属性初始化
实例代码块初始化
构造函数初始化

初始化顺序优先级：静态属性>经静态代码块>实例属性>实例代码块>构造器

注意事项

  1. 静态代码块不管生成多少个对象，其只会执行一次
  2. 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
  3. 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并
  4. 实例代码块只有在创建对象时才会执行

✈3.内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服 务，那么整个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

内部类好比是连接佛珠的线将一颗一颗珠子连接在一起

在这里插入图片描述

代码示例

public class Outer {

    public class Inner{

    }

    public static void main(String[] args) {
        new Outer();
    }
}

//错误认知
public class A{
    
}

class B{
}
//A B是两个独立的类

注意事项

  1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类
  2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

内部类的分类根据内部类定义的位置不同，一般可以分为以下几种形式：

  1. 成员内部类(普通内部类：未static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)(在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。)
  2. 局部内部类(不谈修饰符)、匿名内部类

✈3.1实例内部类

即未被static修饰的成员内部类。

内部类中能不能定义静态成员?

通过代码来验证

public class Outer {

    public class Inner{
    static int age=90;
    }

    public static void main(String[] args) {
        new Outer();
    }
}

运行结果

java: 内部类Demo.Outer.Inner中的静态声明非法
  修饰符 'static' 仅允许在常量变量声明中使用

此时看来是不能的，当给statc修饰的成员变量加上final就可以使用了

public class Outer {

    public class Inner{
    static final  int age=90;
    }

    public static void main(String[] args) {
        new Outer();
    }
}

结论：内部类中要定义静态成员必须使用static final修饰

实例内部类中能不能定义静态成员方法?

代码示例

public class Outer {

    public static void study(){
        System.out.println("好好学习");
    }

    public class Inner{
    static final  int age=90;
    }

    public static void main(String[] args) {
        new Outer();
    }
}

答案是可以

成员内部类创建对象的格式

格式：外部类名.内部类名 对象名 = new  外部类构造器.new 内部类构造器();
范例：Outer.Inner in =  new Outer().new  Inner();

实例内部类代码大全示例

package task;


public class Outer {
    private static int a;
    static int b;
    int c;

    public void methodA() {
        Outer.Inner in=new Outer().new Inner();
        in.name="hmr";
        System.out.println(in.name);
        a = 99;
        System.out.println(a);
    }

    public static void methoB() {
        Outer.Inner in=new Outer().new Inner();
        in.name="叶子秋";
        System.out.println(in.name);
        b = 100;
        System.out.println(b);
    }
	// 实例内部类：未被static修饰
    public class Inner {
        int c;
        static final int age=19;
        String name;
        public void mathodC() {
            // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 90;
            b = 100;
            methodA();
            methoB();
            // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 900;
            System.out.println(c);
            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            System.out.println(Outer.this.c);
        }
    }
}

测试类

package task;


public class OuterText {

    public static void main(String[] args) {
        // 要访问实例内部类中成员，必须要创建实例内部类的对象
		// 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
		// 外部类：对象创建 以及 成员访问
        Outer o=new Outer();
        // 创建实例内部类对象,要得到内部类先要创建外部类
        //Outer.Innner in=new Outer.new Inner(); 方式一
        
        Outer.Inner in=o.new Inner();//方式二
        
        in.mathodC();
    }
}

注意事项

  1. 外部类中的任何成员都可以被在实例内部类方法中直接访问
  2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
  3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名 称.this.同名成员 来访问
  4. 实例内部类对象必须在先有外部类对象前提下才能创建
  5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
  6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

成员内部类的访问

1、成员内部类中是否可以直接访问外部类的静态成员？

可以，外部类的静态成员只有一份可以被共享访问。

2、成员内部类的实例方法中是否可以直接访问外部类的实例成员？

可以的，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

✈3.2静态内部类

什么是静态内部类？

  • 有static修饰，属于外部类本身。

  • 它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已。

静态内部类创建对象的格式：

格式：外部类名.内部类名 对象名 = new 外部类名.内部类构造器;

代码示例

package task;


public class OuterStatic {
    private int a;
    static int b;

    public void methodA(){
        a=90;
        System.out.println(a);
    }
    public static void methodB(){
        b=100;
        System.out.println(b);
    }

    public static class InnerStatic{

        public void method(){
           // a=90;
            b=78;
            methodB();
           // methodA();
        }

    }

}

静态内部类注意事项

  1. 在静态内部类中只能访问外部类中的静态成员
  2. 创建静态内部类对象时，不需要先创建外部类对象

✈3.3局部内部类

局部内部类放在方法、代码块、构造器等执行体中

代码示例

package Demo;

public class Outer {
    int a = 90;
    public void study() {
        int b = 99;
        // 局部内部类：定义在方法体内部
		// 不能被public、static等访问限定符修饰
        class Inner {
            public void print() {
                System.out.println(a);
                System.out.println(b);
            }
        }
        // 只能在该方法体内部使用，其他位置都不能用
        Inner in = new Inner();
        in.print();
    }
    
}

局部内部类的类文件名为： 外部类$N内部类.class

局部内部类了解即可

✈3.4匿名内部类

本质上是一个没有名字的局部内部类，定义在方法中、代码块中、等

作用：简化代码

特点总结：

  • 匿名内部类是一个没有名字的内部类。

  • 匿名内部类写出来就会产生一个匿名内部类的对象。

  • 匿名内部类的对象类型相当于是当前new的那个的类型的子类类型。

代码一

public class Text {
    public static void main(String[] args) {
        Animal a=new Tiger();
        a.run();
    }
}

class Tiger extends Animal {
    @Override
    public void run() {
        System.out.println("老虎跑的快！");
    }
}

abstract class Animal {
    public abstract void run();
}

通过匿名内部类简化代码

public class Text {
    public static void main(String[] args) {
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("老虎跑的快！");
            }
        };
        a.run();
    }
}

abstract class Animal {
    public abstract void run();
}

使用匿名内部类实现老师，学生同时打游戏

package inner;
//简化版一
public class Text2 {
    public static void main(String[] args) {
        IPlayGame ip = new IPlayGame() {
            @Override
            public void PlayGame() {
                System.out.println("学生打游戏！");
            }
        };
       playGame(ip);
        System.out.println("---------------");
        IPlayGame ip2 = new IPlayGame() {
            @Override
            public void PlayGame() {
                System.out.println("老师打游戏！");
            }
        };
        playGame(ip);
    }

    public static void  playGame(IPlayGame i){
        System.out.println("开始游戏");
        i.PlayGame();
        System.out.println("结束游戏");
    }

}

interface IPlayGame {
    void PlayGame();
}
//简化版二
//Lambda只能简化接口中只有一个抽象方法的匿名内部类形式（函数式接口） 

public class Text2 {
    public static void main(String[] args) {
        IPlayGame ip = () ->{
            System.out.println("学生打游戏！");
        };
       playGame(ip);
        System.out.println("---------------");
        IPlayGame ip2 = ()-> {
            System.out.println("老师打游戏！");
        };
        playGame(ip2);
    }

    public static void  playGame(IPlayGame i){
        System.out.println("开始游戏");
        i.PlayGame();
        System.out.println("结束游戏");
    }

}

interface IPlayGame {
    void PlayGame();
}



//简化版三
public class Text2 {
    public static void main(String[] args) {
       playGame(()->   System.out.println("学生打游戏！"));
        System.out.println("---------------");
        playGame(()->   System.out.println("老师打游戏！"));
    }

    public static void  playGame(IPlayGame i){
        System.out.println("开始游戏");
        i.PlayGame();
        System.out.println("结束游戏");
    }
}

interface IPlayGame {
    void PlayGame();
}

匿名内部类对象可以作为参数传递，因为它是当前new的那个类型的子类型，只要方法中的形参部分是它的父类型便可以接收。

上述代码调用过程图

在这里插入图片描述

最后的话

各位看官如果觉得文章写得不错，点赞评论关注走一波！谢谢啦！

在这里插入图片描述

代码块、内部类
qq_42449960的博客
04-18 204
1. 代码块 意义：在类中写上一个大括号，其中写代码 特点：是一个无名的普通方法，不能有返回值 （return） （return：中断代码） 代码块一般用来做什么?： 一般用于初始化数据 和 构造器同样的作用 它在实例化的时候会被自动调用，且只能调用一次 实例化（new）的时候，代码块 比 构造器先调用 1.1静态代码块 相当于静态方法 执行顺序： 静态代码块 ——&gt...
JavaSE-8-类和对象
feng25751006的博客
12-23 568
类和对象的总结
代码块和内部类
koala__的博客
04-17 314
1 代码块 定义：使用{ }定义的一段代码。 分类： 普通代码块 构造块 静态块 同步代码块 1.1 普通代码块 普通代码块：定义在方法中的代码块。 public class Test{ public static void main(String[] args) { {//直接使用{}定义 int x=10; ...
【Java初阶】- - -代码块与内部类
m0_56361048的博客
08-28 1385
4000字详解代码块与内部类
代码块 和内部类
iteye_492的博客
07-29 131
代码块： 普通代码块：新建在方法中的代码叫做普通代码块 构造快：直接在类中的代码 构造快优先于构造方法执行前提是有实例化对象 静态代码块：又static声明的代码块，静态代码块优先于主方法执行 不管实例化多少个对象，静态代码块只执行一次。功能是为静态属性初始化。 public class CodeDemo4{ static{ System.out.println(“Hello...
就业班JavaSE--day05 每日作业卷1
08-08
JavaSE的第五天作业主要涵盖了Java基础中的几个关键知识点，包括`Object`类、`equals()`...以上内容详细解释了JavaSE第五天作业涉及的主要概念和操作步骤，这些基础知识对于理解和处理Java程序中的常见问题至关重要。
就业班JavaSE--day05 每日作业卷答案1
08-08
8. **throw与throws的区别**：`throw`用于在方法内部抛出一个已经创建好的异常对象，结束当前方法的执行并将异常传递给调用者。`throws`则用于方法声明，表示方法可能抛出异常，提醒调用者需要处理这些异常。 9. **...
JavaSE--第二阶段2
HK_Milky的博客
08-15 300
1、枚举和注解 1、枚举介绍 枚举类【枚: 一个一个 举： 例举 , 即把具体的对象一个一个例举出来的类就称为枚举类】 2、自定义类实现枚举 不需要提供setXxx方法，因为枚举对象值通常为只读 对枚举对象 / 属性使用final+static共同修饰，实现底层优化 枚举对象名通常使用全部大写 枚举对象根据需要，也可以有多个属性 构造器私有化 本类内部创建一组对象 对外暴露对象（通常为对象添加public final static ） 可以提供get方法，不不提供set方法
JavaSE --- 多线程
MemoryTa的博客
08-06 306
多线程。。概述生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为Object类的等待和唤醒方法。............
Java基础——代码块&内部类
Clannad191的博客
06-12 303
文章目录一、代码块1. 代码块概述2. 静态代码块3. 非静态代码块：4. 注意点二、内部类1. 内部类概述2. 成员内部类2.1 一方面，作为外部类的成员：2.2 另一方面，作为一个类：3. 内部类主要只需关注如下3个问题：4.1 如何实例化成员内部类的对象4.2 如何在成员内部类中区分调用外部类的结构4.3 开发中局部内部类的使用 一、代码块 类的成员之四：代码块（初始化块） 1. 代码块概述...
Java内部类
weixin_65476629的博客
08-07 273
当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。} } // OutClass是外部类 // InnerClass是内部类【注意事项】定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类} // A 和 B是两个独立的类，彼此之前没有关系。
JavaSE----代码块、内部类
weixin_44235759的博客
10-13 139
类的成员之四：代码块(初始化块)（重要性较属性、方法、构造器差一些） 1.代码块的作用：用来初始化类、对象的信息 分类：静态代码块 vs 非静态代码块 静态代码块： 随着类的加载而执行,而且只执行一次 作用：初始化类的信息 静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构 非静态代码块： 每创建一个对象，就执行一次非静态代码块 作用：可以在创建对象时，对对象的属性等进行初始化 非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法 实例化子类对象时，涉及到父类
非静态内部类不能有静态声明
autumn20080101的专栏
01-08 4844
/** * Description: * Copyright (C), 2005-2008, Yeeku.H.Lee * This program is protected by copyright laws. * Program Name: * Date: * @author Yeeku.H.Lee kongyeeku@163.com * @version 1.0 */ pu
2024年《JavaSE-第八章》-代码块与内部类_java静态声明非法怎么改(1)，学习指南
最新发布
2401_84975543的博客
05-13 652
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！ } package Demo;public class PeachBlossomIslandStudent { private String name; pr
java 静态声明非法_java – 静态最终字段的非法正向引用错误
weixin_33249310的博客
02-25 295
你对前向参考的理解是正确的.对第9行的foo的引用根本不是前向引用,因为它在声明之前没有以文字形式显示(参见The Java Language Specification第8.3.2.3节中什么构成前向引用的定义).您观察到的行为是javac错误的症状.请参见this bug report.问题似乎在编译器的较新版本中已修复,例如. OpenJDK 7.它仅影响用作最终字段的初始化器的前向引用.这...
Java——送命面试题
LiLi_code的博客
01-16 949
1、写出程序运行结果 interface A{} class B implements A{ public String func(){ return "func"; } } public class Test{ public static void main(String[] args){ A a = new B(); a.func(); System.out.pr...
java 静态声明非法,内部类中的非法静态声明
weixin_39617473的博客
02-12 1355
import java.lang.*;class mythread implements Runnable {Thread t1;String name = "";mythread(String thname){name = thname;t1 = new Thread(this, name);System.out.println("Child thread starting" + t1 );}@...
评论 23
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潇潇雨声迟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值