类的成员之一：成员内部类、局部内部类

1.成员内部类：在类中声明另一个类，外面的类称为“外部类”，里面的类称为“内部类”

①：是类的成员之一。 （属性、方法、构造器、代码块）
②成员内部类可以使用四种访问控制修饰符（public 、protected、default、private）
③成员内部类可以使用static final修饰
④内部类与外部类拥有相同的特性

 

package JavaLearning;
/*内的成员之一：内部类

1.成员内部类：在类中声明另一个类，外面的类称为“外部类”，里面的类称为“内部类”

①：是类的成员之一。 （属性、方法、构造器、代码块）
②成员内部类可以使用四种访问控制修饰符（public 、protected、default、private）
③成员内部类可以使用static final修饰
④内部类与外部类拥有相同的特性
2.局部内部类：*/

public class InnerClassTest {

    public static void main(String[] args) {
        //创建静态内部类的对象
       Person.Mobile pm= new Person.Mobile();
       pm.show();

       //创建非静态内部类的对象
        Person p=new Person();
        Person.Computer pc=p.new Computer();
        pc.setName("IBM");
        System.out.println(pc.getName());

    }

}
class  Person{
    private String name="颤三";
    private int age;

    public Person() {
    }

    public Person(int age,String name) {
        this.age = age;
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

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


    //成员内部类
    public class Computer{
        private String name="联想";

        public Computer() {
        }

        public Computer(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            System.out.println("局部变量参数name:"+name);
            System.out.println("局部内部类对象的属性name："+this.name);
            System.out.println("外部类对象的属性name:"+Person.this.name);
            System.out.println("外部类对象的属性："+age);
            this.name = name;
        }

        @Override
        public String toString() {
            return "Computer{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

    //实现对类的隐藏
    private class Head{

    }


    //静态内部类
    static class Mobile{
        public void show(){
            System.out.println("静态内部类中的方法");
        }
    }

}

 

 

 

 局部内部类

package JavaLearning;

import java.util.Comparator;

public class InnerClassTest2 {

    //局部内部类
    public void show(){
        class Inner{

        }
    }

    //
    public Flyer getFlyer(){//接口
        //Flyer f=new Flyer();错误,接口不能创建实例
        Bird b=new Bird();//返回实现类的实例
        return b;
    }

    public Person getPerson(){
        return new Person();
    }

    public Comparable getComparator1(){//只在当前方法内使用
        Comparable com=new MyComparator();
        return com;
    }

    //局部内部类
    public Comparable getComparator2() {
        class MyComparator implements Comparable {

            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        Comparable com = new MyComparator();
        return com;
    }

    //匿名内部类
    public Comparator getComaprator3(){
        Comparator com=new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };

        return com;
    }

    //匿名内部类+匿名对象
    public Comparator getComparator4(){
        return new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };
    }
}

 

Comparator为内置接口 

局部内部类和局部变量的注意：

①局部内部类中使用同级别的局部变量时，该局部变量必须使用final修饰（jdk1.7必须显示的加final        jdk1.8默认为final        ）