深入了解Java类 《大学我玩够了你呢？30天轻松搞定 Java》

深入了解Java类 (嵌套类、内部类以及JavaBean)

一、嵌套类的分类

静态嵌套类	static修饰；必须通过对象来访问其包围类的成员
非静态嵌套类（内部类）	内部类可以访问它的外部类的所有变量和方法，并且可以像外部类的其他非静态成员那样以同样的方式直接引用他们

二、内部类

I 代码展示

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class 嵌套类与内部类 {      //外部类
    String string = new String("hello");
    static String string1 = new String("hello");
    String name = new String("Nick");
    public static void main(String[] args) {
        // Dog.shout();  非法，编译无法通过：不可直接调用静态内部类的成员
        Dog dog = new Dog();
        dog.shout();//可以通过创建类的对象进行访问
        int b=dog.earamonut;    //通过创建的对象访问内部类的公有成员
        int a =dog.nouseamount;//通过创建的对象访问内部类的私有成员
        嵌套类与内部类 o = new 嵌套类与内部类();
        o.test();
        CloseFrameTest closeFrameTest = new CloseFrameTest();
    }
//一、外部类中定义内部类
    static class Dog{//外部类中定义的内部类  静态
        private int nouseamount = 1;
        public int earamonut = 2;
        public void shout(){//静态成员方法
            System.out.println("汪汪汪！");
            //System.out.println(string);   非法，编译无法通过：不能直接访问外部类的非静态成员
            System.out.println(string1);//可以访问外部类的静态成员
            System.out.println("我有 "+nouseamount+" 个鼻子");//可以访问本内部类中的变量和方法
        }
    }
    class Inner1 {//内部类1 非静态
        public int a = 1;
        private int b = 2;
        int c = 3;
        public void display(){
            System.out.println("MY name is " + name);//可以访问外部类的成员
        }
    }
    void test(){//外部类的方法
        Inner1 inner1 = new Inner1();
        inner1.display();
        //System.out.println(a);   非法，编译无法通过：不可直接访问内部类的任何成员
        System.out.println(inner1.a);//通过创建的对象来访问内部类的成员
        Inner2 inner2 = new Inner2();
        inner2.tranfer();
    }
    class Inner2{//内部类2 非静态
        Inner1 inner1 = new Inner1();
        public void tranfer(){
            //System.out.println(a);  非法，编译无法通过：不可直接访问同等级内部类的任何成员
            //System.out.println(Inner1.a);
            inner1.display();//通过创建的对象来访问同等级内部类的方法
            System.out.println("sum = " + inner1.a + inner1.b + inner1.c);////通过创建的对象来访问同等级内部鳄梨的变量
        }
    }

    //二、方法中定义内部类
    int out_x = 100;//外部类变量
    public void test1(){//外部类方法test1
        class InnerOne{
            String x = "x";
            void display(){
                System.out.println(out_x);//可以直接访问外部变量
            }
        }
        InnerOne innerOne = new InnerOne();
        innerOne.display();
    }
    public void test2(){//外部类方法test2
        //public String s1 = " ";  非法，编译无法通过：不可定义，只能用final修饰
        //static String s2 = " ";  非法，编译无法通过：不可定义，只能用final修饰
        String s3 = "hello";//可以不修饰
        final String s4 = "hello";
        class InnerTwo{
            public void printInfo(){
                System.out.println(out_x);//可以直接访问外部类变量
                System.out.println(s3);//？？？？？为啥这里可以访问
                System.out.println(s4);//只能访问本方法中得final变量
            }
        }
        InnerTwo innerTwo = new InnerTwo();
        innerTwo.printInfo();
    }
//三、匿名内部类
static class CloseFrameTest extends Frame{
        CloseFrameTest(){
            this.setSize(200,200);
            this.setVisible(true);
            this.addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    System.out.println(0);
                }
            });
        }
}
}

II 总结

1. 在一个类(外部类)中直接定义的内部类

• 静态嵌套类中，内部类不能访问外部类的非静态成员。
• 静态嵌套类中，当外部类访问内部类的成员时，不能直接访问，但可以通过内部类来访问，
• 这是因为静态嵌套内的所有成员和方法默认为静态的。
• 内部类的变量成员只在内部类可见，若外部类或同层次的内部类需要访问，需要先创建内部类的对象。
• 不可以直接访问内部类的变量。

2. 在一个方法（外部类的方法）中定义的内部类

• 定义在方法内部的内部类可见性更小，它只在方法内部可见。
• 方法中的内部类不可访问本方法的成员变量，只能访问本方法的final变量。
• 在方法内部定义成员时，只允许使用final修饰词或不加修饰词。

3. 匿名内部类

• 通常使用在Java的事件处理上。

III 疑问？？？？？

 //二、方法中定义内部类
    int out_x = 100;//外部类变量
    public void test1(){//外部类方法test1
        class InnerOne{
            String x = "x";
            void display(){
                System.out.println(out_x);//可以直接访问外部变量
            }
        }
        InnerOne innerOne = new InnerOne();
        innerOne.display();
    }
    public void test2(){//外部类方法test2
        //public String s1 = " ";  非法，编译无法通过：不可定义，只能用final修饰
        //static String s2 = " ";  非法，编译无法通过：不可定义，只能用final修饰
        String s3 = "hello";//可以不修饰
        final String s4 = "hello";
        class InnerTwo{
            public void printInfo(){
                System.out.println(out_x);//可以直接访问外部类变量
                System.out.println(s3);//？？？？？为啥可以访问非final变量？？？
                System.out.println(s4);//只能访问本方法中得final变量
            }
        }
        InnerTwo innerTwo = new InnerTwo();
        innerTwo.printInfo();
    }

方法中的内部类不可访问本方法的成员变量，只能访问本方法的final变量，但代码里竟然可以，凸(艹皿艹 )，我去研究研究。。。。。

三、JavaBean组件技术

JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。属性的类型保持唯一，get方法返回值必须和set方法参数类型一致。每个属性要有对应的get、set方法（隐藏属性可以没有）。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性。众所周知，属性名称符合这种模式，其他Java 类可以通过自身机制发现和操作这些JavaBean 属性。 换句话说，javabean就是一个java的类，只不过这个类你要按上面提到的一些规则来写，比如必须是公共的啊，无参构造啊等等，按这些规则写了之后，这个javabean可以在程序里被方便的重用，使开发效率提高。

public class JavaBean组件技术 {
    public static void main(String[] args) {
        Student student = new Student();
        //通过get、set方法对属性进行访问和修改
        student.setHeight(187);
        student.setWeight(70);
        student.setName("cc雪影");
        student.setSex("男");
        student.setId(123);
        System.out.println(student.getName()+" 身高："+student.getHeight()+
                " 体重："+student.getWeight()+"kg ");
    }
}
class Student {
    private int id;//变量须是 private类型
    private String name;
    private String sex;
    private int height;
    private int weight;
    public Student(){//必须得有无参构造器

    }
    //定义JavaBean的get、set方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

学习从点滴开始，学到的东西可能会忘记，记得点赞收藏哦

System.out.println("我选择滑稽取宠");