java 内部类学习笔记

open_test01

已于 2022-08-01 23:34:50 修改

阅读量170

点赞数 2

分类专栏： java学习文章标签：学习 java

于 2022-06-29 22:22:20 首次发布

本文链接：https://blog.csdn.net/dafsq/article/details/125508286

版权

java学习专栏收录该内容

34 篇文章 2 订阅

订阅专栏

概述

内部类就是定义在一个类里面的类。

public class People{
    // 内部类
    public class Heart{  
    }
}

场景：当一个事物的内部，还有一个部分需要一个完整的结构进行描述时。

内部类的作用

内部类通常可以方便访问外部类的成员，包括私有的成员。

内部类提供了更好的封装性，内部类本身就可以用private ，protectecd等修饰，封装性可以做更多控制。

静态内部类

有static修饰，属于外部类本身。
它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已。

public class A{
        // 静态成员内部类    
        public static class B{
        }

}

静态内部类创建对象:

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

例如：

//外部类
public class Out {
    public static class In{//内部类
        private String name;
        private  int age;
        public static String cname;

        public In(String name, int age) { //内部类的有参构造器
            this.name = name;
            this.age = age;
        }

        public In() { //内部类的无参构造器
        }

        //get 、 set 方法

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public static String getCname() {
            return cname;
        }

        public static void setCname(String cname) {
            In.cname = cname;
        }
    }

}

public class test {
    public static void main(String[] args) {
        Out.In a = new Out.In();
        a.setName("香克斯");
        a.setAge(40);
        System.out.println(a.getName()+"  "+a.getAge());

    }
}

静态内部类中可以直接访问外部类的静态成员

静态内部类中不可以直接访问外部类的实例成员

成员内部类

无static修饰，属于外部类的对象。

public class Outer {
    // 成员内部类    
    public class Inner {    
    }
}

成员内部类创建对象：

外部类名.内部类名 对象名 = new  外部类构造器.new 内部类构造器();

例如：

//外部类
public class Out {
    public class In{
        private String  name;//内部类
        private  int age;
        private  static String cname; //成员内部类中可以有静态成员变量

        public static void eat(){ //成员内部类中可以有静态方法

        }

        public In(String name, int age) { //有参构造器
            this.name = name;
            this.age = age;
        }


        public In() {//无参构造器


        }
        //get、 set方法

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getCname() {
            return cname;
        }

        public void setCname(String cname) {
            this.cname = cname;
        }
    }

}

public class test {
    public static void main(String[] args) {
        Out.In i = new Out().new In();
        i.setName("路飞");
        System.out.println(i.getName());
    }
}

静态内部类中可以直接访问外部类的静态成员

静态内部类中可以直接访问外部类的实例成员

内部类中各范围中变量的访问

//外部类
public class Out {
    private int a = 10;  //外部类对象 访问时 外部类名.this.对象

    public class In { //内部类
        private int b = 20; //成员内部类的对象变量 访问使用this关键字

        public void print() {
            int c = 30;
            System.out.println(c);//输出30
            System.out.println(this.b);//输出20
            System.out.println(Out.this.a);//输出10
        }

    }
}

局部内部类（了解即可）

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

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

匿名内部类

本质上是一个没有名字的局部内部类。

作用：方便创建子类对象，最终目的是为了简化代码编写。

格式：

new 类|抽象类名|或者接口名() {
       重写方法;
};

例如：

abstract class F{ //定义父类抽象类
    abstract void eat();
}

public class test {
    public static void main(String[] args) {
        F a = new F() {
            @Override //重写
            void eat() {
                System.out.println("很能吃");
            }
        };
        a.eat();
    }
}

匿名内部类是一个没有名字的内部类，同时也代表一个对象。

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

匿名内部类的使用

如：

某个学校需要让学生参加游泳比赛

常规写法有子类：

/*
游泳接口
*/
public interface Swimming {
    void swim();
}

public class test {
    public static void main(String[] args) {
        Swimming s = new Student();
        goSwimming(s);
    }

    // 定义一个方法让所有角色进来一起比赛
    //需求：goSwimming方法
    public static void goSwimming(Swimming s) {
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }
}

class Student implements Swimming{

    @Override
    public void swim() {
        System.out.println("学生游泳比赛");
    }
}

匿名内部类的写法：

/*
游泳接口
*/
public interface Swimming {
    void swim();
}

public class test {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生游泳比赛");
            }
        };
        goSwimming(s);

    }

    // 定义一个方法让所有角色进来一起比赛
    //需求：goSwimming方法
    public static void goSwimming(Swimming s) {
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }
}

运行是以回调形式：

匿名内部类可以作为一个对象，直接传输给方法。

使用匿名内部类的案例：

通过GUI编程理解匿名内部类的使用

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


public class test {
    public static void main(String[] args) {
        //创建窗口
        JFrame windo = new JFrame("登录界面");

        //定义一个桌布
        JPanel panel = new JPanel();
        windo.add(panel);

        //创建一个按钮对象
        JButton button1 = new JButton("登录");

        //使用匿名内部类
        button1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent actionEvent) {
                //提示框
                JOptionPane.showMessageDialog(windo, "点击了一下");//监听对象并输出

            }
        });//监听器和接口对象


        //将按钮对象添加到桌布对象中
        panel.add(button1);
        //设置窗口大小
        windo.setSize(300, 400);
        //展示窗口
        windo.setVisible(true);
        //窗口居中
        windo.setLocationRelativeTo(null);
    }
}