JAVA--内部类

时刻牢记！！

类的成员只有5类

1. 属性

2. 方法

3. 构造器

4. 代码块

5. 内部类/接口

内部类

内部类是将一个类定义在另一个类的内部，称为内部类。

// 例
public class Demo {
    // A类是Demo的内部类
    class A{
        static {
            int a = 10;
        }
        A()
        {
            System.out.println("内部类的构造进行");
        }
    }
}

实例操作

public class Demo {
​
    static {
        System.out.println("Demo静态");
        A.play();
    }
    public static int fun()
    {
        System.out.println("Demo 的静态方法");
        return 11;
    }
    int a = Demo.fun();
​
    static void fun1()
    {
        System.out.println("fun1");
    }
    
​
    Demo()
    {
        System.out.println("Demo的构造");
    }
    class A{
        int a =Demo.fun();
        static {
            System.out.println("内部类的静态");
        }
​
        static void play()
        {
            System.out.println("内部类的play方法");
        }
        A()
        {
            System.out.println("内部类的构造进行");
        }
    }
​
​
    public static void main(String[] args) {
        // 在外部调用内部类
        Demo d = new Demo();
        A a = d.new A();
        Demo.A.play();
​
    }
​
}

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

执行性代码只能写在代码块内执行

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

public class Demo {
​
    static {
        System.out.println("Demo静态");
        A.play();
    }
    public static int fun()
    {
        System.out.println("Demo 的静态方法");
        return 11;
    }
    int a = Demo.fun();
    Demo.fun1();   //  这里是不对的，必须要放在代码块内执行
    static void fun1()
    {
        System.out.println("fun1");
    }
}

内部类和外部类可以互相访问类中的成员，包括私有的。

一个类可以有多个内部类，内部类可以实现接口和继承类。内部类可以解决 java 类单继 承问题，因为内部类和外部类可以相互访问。

• 内部类的实例化，内部类依托于外部类，所以内部类的实例化要先实例化外部类，然后在 实例化内部类

• 静态内部类不能直接访问外部类的成员，可以直接访问外部内的静态成员

内部类和外部类区别

访问修饰符： 外部类只能有两种访问权限： public 以及 package-access 内部类可以有四种访问权限： public / protected / package-access / private static 修饰： 外部类不可以使用 static 修饰类，内部类可以 使用：外部类可以直接被使用，内部类的使用则依赖于外部类

匿名类

匿名类指类没有明确名称的类

​
public class anonymity {
    abstract static class Zoon{
        abstract void play();
​
    }
    public static void main(String[] args) {
        class Cat extends Zoon{
            /**
             *
             */
            @Override
            void play() {
                System.out.println("猫1会叫");
            }
        }
​
        Zoon cat1 = new Cat();
​
        Zoon cat2 = new Zoon() {
            @Override
            void play() {
                System.out.println("猫2会叫");
            }
        };
        cat1.play();
        cat2.play();
    }
}
​

上面的例子中

cat1和cat2都实现了对抽象类的重写，cat2实现是利用匿名类来实现的。

lambda表达式在匿名函数中的使用

1. 无参无返回

2. 有参数无返回值

3. 有参数无返回值，数据类型可省略，称为类型推断

4. 有多个参数，有返回值

// 1.无参无返回
​
​
package com.kfm.code.test.Demo0829.Lambda;
​
public interface demo1 {
    void show();
}
class Test{
    public static void main(String[] args) {
        demo1 a1 = () -> System.out.println("我是show()方法");
        demo1 a2 = () ->
        {
            System.out.println("我也是show方法");
            System.out.println("我是第二段");
        };
        a1.show();
        a2.show();
    }
​
}
​
​
​

//2.有参数无返回值
​
public interface demo2 {
    void show(String s);
}
class Test2{
    public static void main(String[] args) {
​
        demo2 a1 = (String s) -> System.out.println("传入的值为" + s);
        demo2 a2 = (String s) ->
        {
            System.out.println("我是第二段");
            System.out.println("我也是show方法" + s);
            
        };
        a1.show("你好");
        a2.show("你好");
​
​
    }
}
​

//3.有参数无返回值，数据类型可省略，称为类型推断
//有且只有一个参数，并且无返回
​
public interface demo3 {
    void show(String str);
}
class Test3
{
    public static void main(String[] args) {
        demo3 a1 = str -> System.out.println("我是show()方法" + str);
        demo3 a2 = str ->
        {
            System.out.println("我是第二段");
            System.out.println("我也是show方法" + str);
​
        };
        a1.show("你好世界");
        a2.show("你好世界");
​
​
    }
}

//4.有多个参数，有返回值
​
public interface demo4 {
    int add(int x,int y);
}
​
​
class Test4
{
    public static void main(String[] args) {
        demo4 t;
        t = (x,y) -> {
            return x+y;
        };
        System.out.println(t.add(2,3));
        t = (x,y) -> x+y;
        System.out.println(t.add(5,9));
​
​
    }
}
​