Java学习笔记 （成员内部类、静态内部类、匿名内部类、方法内部类）

2023-04-25 11:14:12 浏览数 (1)

内部类

  • 在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类
  • 与之对应，包含内部类的类称为外部类
  • 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类，更好的实现了信息隐藏
成员内部类

1、内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化 2、内部类的访问修饰符，可以任意，但是访问范围会受到影响 3、内部类可以直接访问外部类成员;如果出现同名属性，优先访问内部类中定义的 4、可以使用外部类.this.成员的方式访问外部类中同名的成员信息 5、外部类访问内部类信息，需要通过内部类实例，无法直接访问 6、内部类编译后.class文件命名:外部类$内部类.class 7、内部类中是否可以包含与外部类相同的方法签名的方法

代码语言：javascript复制
package com.imooc.People;

public class Person {
    public int age;

    public Heart getHeart(){
        new Heart().temp = 10;
        return new Heart();
    }
    public void eat(){
        System.out.println("人在吃东西");
    }


    /**
     * 成员内部类
     * 1、内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
     * 2、内部类的访问修饰符，可以任意，但是访问范围会受到影响
     * 3、内部类可以直接访问外部类成员;如果出现同名属性，优先访问内部类中定义的
     * 4、可以使用外部类.this.成员的方式访问外部类中同名的成员信息
     * 5、外部类访问内部类信息，需要通过内部类实例，无法直接访问
     * 6、内部类编译后.class文件命名:外部类$内部类.class
     * 7、内部类中是否可以包含与外部类相同的方法签名的方法
     */


    public class Heart{
        int temp = 222;
        public String beat(){
            int age = 23;
            return age   "心脏在跳动" "aaaa" Person.this.age;
        }
    }
}
静态内部类
  • 静态内部类对象可以不依赖于外部类对象， 直接创建。
  • 静态内部类不能直接访问外部类的非静态成员， 但可以通过 “外部类对象· 成员” 的方式访问。
  • 外部类中可以通过“ 类名· 成员名" 的方式直接访问内部类中静态成员 定义在外部类方法中的内部类， 也称局部内部类。
  • 方法内部类只在其定义所在的方法的内部可见， 即只在该方法内可以 使用。
  • 方法内部类不能使用访问控制符和static 修饰符， 但可以使用final和abstract 修饰。
  • 编译后产生： 外部类$ 数字· class
代码语言：javascript复制
package com.imooc.People;

public class Person1 {
    public static int age = 12;

    public Heart getHeart(){
        return new Heart();
    }
    public void eat(){
        System.out.println("人在吃东西");
    }
    

    public static class Heart{
        public static int age = 222;

        public static void say(){
            System.out.println("hello");
        }
        public String beat(){
            new Person1().eat();
            return Person1.age   "岁心脏在跳动";
        }
    }
}
代码语言：javascript复制
package com.imooc.test;

import com.imooc.People.Person;
import com.imooc.People.Person1;

public class peopletest {
    public static void main(String[] args) {
        Person1 lili = new Person1();
        lili.age = 12;
        Person1.Heart myHeart = new Person1.Heart();
        System.out.println(myHeart.beat());
        Person1.Heart.say();
    }
}
方法内部类
  • 定义在外部类方法中的内部类， 也称局部内部类。
  • 方法内部类只在其定义所在的方法的内部可见， 即只在该方法内可以使用。
  • 方法内部类不能使用访问控制符和static 修饰符， 但可以使用final和abstract 修饰。
  • 编译后产生： 外部类$ 数字· class
代码语言：javascript复制
package com.imooc.People;

public class Person1 {
    public static int age;


    public Object getHeart(){
        //方法内部类
        /**
         * 1、定义在方法内部，作用范围也在方法内
         * 2、和方法内部成员使用规则一样，class前面不可以添加publicprivate。。。。
         * 3、类中不能包含静态成员
         * 4、类中可以包含final、abstract修饰的成员
         */
          class Heart{
            public int temp = 222;
            public int age = 23;

            public void eat(){

            }
            public String beat(){
                new Person1().eat();
                return  Person1.age   "岁心脏在跳动";
            }
        }
        return new Heart().beat();
    }

    public void eat(){
        System.out.println("人在吃东西");
    }



}
匿名内部类

如果某个类的实例只是用一次， 则可以将类的定义与类的创建， 放到一 起完成， 或者说在定义类的同时就创建一个类。以这种方法定义的没有 名字的类称为匿名内部类。 适用场景

  • 只用到类的一个实例
  • 类在定义后马上用到
  • 给类命名并不会使代码更容易被理解 使用原则
  • 不能有构造方法， 可以通过构造代码块实现数据初始化。
  • 不能定义任何静态成员、静态方法。
  • 不能使用pub 、protected 、private 、static、 abstract、 final修饰。
  • 因匿名内部类也是局部内部类， 所以局部内部类的所有限制都对其 生效。
  • 一个匿名内部类一定是在new 的后面， 用其隐含实现一个接口或继承一个类， 但是两者不可兼得。
  • 只能创建匿名内部类的一个实例。
  • 匿名内部类在编译的时候由系统自动起名为Outter $ 1 · class
  • 一般来说， 匿名内部类用于继承其他类或是实现接口， 并不需要增加额外的方法， 只是对继承方法的实现或是重写。
  • 通过匿名内部类返回的是一个对象的引用， 所以可以直接使用或 将其复制给一个对象变量。
代码语言：javascript复制
package com.imooc.anonymous;

//public class Man extends Person{
//    @Override
//    public void read() {
//        System.out.println("男生看武侠");
//    }
//}
代码语言：javascript复制
package com.imooc.test;

//import com.imooc.anonymous.Man;
import com.imooc.anonymous.Person;
//import com.imooc.antonymous.Woman;

public class PerTest {
//     public void getRead(Man man) {
//         man.read();
//     }
//
//    public void getRead(Woman woman) {
//        woman.read();
//    }

    public void getRead(Person person) {
        person.read();
    }

    public static void main(String[] args) {
        PerTest test = new PerTest();
        //方案1
//        Man one = new Man();
//        Woman two = new Woman();
//        test.getRead(one);
//        test.getRead(two);
        /**
         * 1、匿名内部类没有类型名称、实例对象名称
         * 2、编译后的文件命名:外部类$数字.class
         * 3、无法使用private、public、abstract、static修饰
         * 4、不能编写构造方法，可以添加构造代码块
         * 5、不能出现静态成员
         * 6、匿名内部类可以实现接口也可以继承父类，但是不可兼得
         */
        test.getRead(new Person() {
            @Override
            public void read() {
                System.out.println("fuck!!!");
            }
        });
        System.out.println("=============================");
        //方案2

    }
}
java public 编译 对象 学习笔记

0 人点赞