码迷,mamicode.com
首页 > 编程语言 > 详细

java中的内部类

时间:2019-09-15 11:14:46      阅读:80      评论:0      收藏:0      [点我收藏+]

标签:return   事物   func   fun   create   int   匿名内部类   method   etc   

概述

将一个类定义在另一个类的里面,里面的那个类就称为内部类(内置类,嵌套类)

分析事物A时,发现该事物A描述中还有事物B,而且这个事物B还在访问被描述事物A的内容,将事物B定义成内部类来描述。

特点

  1. 内部类可以直接访问外部类中的成员;
  2. 外部类要访问内部类,必须建立内部类的对象;

举例:

package innerdemo;

public class InnerDemo1 {
    public static void main(String[] args) {
        Outer.Inner in = new Outer().new Inner(); // 直接访问内部类的方法
        in.show();

        Outer o = new Outer();//
        o.method();
    }
}
class Outer{

    private int num = 3;
    // 内部类
    class Inner{
        void show(){
            num = 100;
            System.out.println("内部类run..."+num);
        }
    }

    public void method(){
        Inner in = new Inner(); //外部类要访问内部类,必须建立内部类的对象;
        in.show();
    }
}

修饰符

  1. 直接访问外部类中的内部类中的成员:(不多见)

    外部类名.内部类名 变量名 = new 外部类名(). new 内部类名();

    Outer.Inner in = new Outer().new Inner();

    in.show();

  2. 内部类是静态的类,相当于一个外部类。外部类只要一加载,内部类就存在了,所以直接new一个内部类对象出来;

    Outer.Inner in1 = new Outer.Inner();

    public class InnerClassDemo {
        public static void main(String[] args) {
            // 内部类是静态的。相当于一个外部类
            Outer.Inner in1 = new Outer.Inner();
            in1.show();
        }
    }
    class Outer{
        private static int num = 3;
        // 内部类
        static class Inner{
            void show(){
                System.out.println("内部类run..."+num);
            }
        }
    }
  3. 如果内部类是静态的,成员是静态的,就不需要对象了。如果内部类中定义了静态成员,该内部类也必须是静态的。

    package java_demo_2;
    
    public class InnerClassDemo {
        public static void main(String[] args) {
            Outer.Inner.function();
        }
    }
    class Outer{
        private static int num = 3;
        // 内部类
        static class Inner{
            void show(){
                System.out.println("内部类run..."+num);
            }
            public static void function(){
                System.out.println("内部类是静态的,成员也是静态的,不需要创建对象"+num);
            }
        }
    }

细节

package java_demo_2;

public class InnerClassDemo {
    public static void main(String[] args) {
        new Outer().method();
    }

class Outer{
    int num = 3;
    // 内部类
    class Inner{
        int num = 4;
        void show(){
            int num = 5;
            System.out.println(num); // num 5
            System.out.println(this.num); // 4 局部和成员变量重名
            System.out.println(Outer.this.num); // 3
        }
    }
    void method(){
        new Inner().show();
    }
}

为什么内部类能直接访问外部类中成员呢?

那是因为内部类持有了外部类的引用。外部类名.this

局部内部类

内部类可以存放在局部位置上,可以放在方法中,放在代码块中。

class Outer1{

    int num = 3;

    void method(){
        // 内部类在方法中

        class Inner{
            void show(){
                System.out.println("方法中的内部类:"+num);
            }
        }
        // 创建对象
        Inner in = new Inner();
        in.show();
    }

    {
        // 内部类在代码块中
        class Inner2{
            void show(){
                System.out.println("代码块中的内部类:" + num);
            }
        }
        Inner2 in2 = new Inner2();
        in2.show();
    }
}

内部类在局部位置上只能访问局部中被final修饰的局部变量;

class Outer{
    int num = 3;
    void method(){

        final int x  = 9; // 这个好像都行 int x = 9 不报错;
        class Inner{
            void show(){
                System.out.println("show..."+x); // 内部类在局部位置上只能访问局部中被final修饰的局部变量;
            }
        }
        // 创建对象
        Inner in = new Inner();
        in.show();
    }
}

匿名内部类

概述

内部类的简写格式。要简写,必须和外部类有关系。必须有前提:内部类必须继承或者实现一个外部类或者接口。

格式: new 父类or接口(){子类内容};

匿名内部类,其实就是一个匿名子类对象;这个对象比较胖。

按道理要先继承父类,重构方法,再创建对象调用方法如:

class Inner extends InnerDemo{
    void show() {
        System.out.println("内部类run..." + num);
    }
}
public void method() {
   new Inner().show();
}

现在直接在方法里,进行new 父类(){重构方法;}

new InnerDemo(){ // 匿名内部类,new 他爹(){把方法重写;}
    void show(){
        System.out.println("show..."+num);
    }
}

具体代码如下:

public class InnerClassDemo {
    public static void main(String[] args) {
        new Outer().method();
    }
}

// 抽象类
abstract class InnerDemo{
    abstract void show();
}
class Outer {

    private int num = 3;

    // 内部类
//    class Inner {
//        void show() {
//            System.out.println("内部类run..." + num);
//        }
//
//    }

    public void method() {
//        new Inner().show();
        new InnerDemo(){ // 匿名内部类,new 他爹(){把方法重写;}
            void show(){
                System.out.println("show..."+num);
            }
        }.show();
    }
}

应用

注释部分:普通内部类继承外部接口时代码:

interface Inter{
    void show1();
    void show2();
}
class Outer {
    private int num = 3;

    // 内部类
    /*
    class Inner implements Inter {
        public void show1(){

        }
        public void show2(){

        }
    }
    */
    public void method(){

//        Inner in = new Inner();
//        in.show1();
//        in.show2();
        Inter in = new Inter(){
            public void show1(){

            }
            public void show2(){

            }

        };
        in.show1();
        in.show2();
    }
}

通常的使用场景之一:当函数参数是接口类型时,而且接口中的方法不超过三个,可以用匿名内部类作为实际参数进行传递。

// 正常写
public class InnerClassDemo {
    public static void main(String[] args) {
    
    show(new InterImpl());
}
    public static void show(Inter in){
        in.show1();
        in.show2();
    }
}
interface Inter{
    void show1();
    void show2();
}

class InterImpl implements Inter{
    public void show1(){}
    public void show2(){}
}

// 简写,将匿名内作为实际参数传递
public class InnerClassDemo {
    public static void main(String[] args) {
    
    show(new Inter(){
        public void show1(){}
        public void show2(){}
    });
}   
    public static void show(Inter in){
        in.show1();
        in.show2();
    }
}
//接口
interface Inter{
    void show1();
    void show2();
}

分类

  • 成员内部类(静态内部类和非静态内部类)
  • 局部内部类
  • 匿名内部类

成员内部类

  • 静态内部类:直接通过外部类调用静态内部类的构造器
  • 非静态内部类:先创建外部类的对象,再通过外部类的对象调用内部类的构造器或者
    外部类名.内部类名 对象名 = new 外部类型().new 内部类型();
package innerdemo;

/**
 * @ClassName: InnerClassDemo
 * @author: benjamin
 * @version: 1.0
 * @description: TODO
 * @createTime: 2019/06/11/10:11
 */

public class InnerClassDemo {
    public static void main(String[] args) {
        // 创建静态内部类的对象
        Person.Dog d = new Person.Dog();// 直接通过外部类调用静态内部类的构造器
        //创建非静态内部类的对象
//        Person.Bird b = new Person().new Bird();
        Person p = new Person();
        Person.Bird b = p.new Bird();// 通过外部类的对象调用内部类的构造器
        b.info();

    }
}

class Person{

    String name;
    int age;

    // 非静态成员内部类
    class Bird{
        String name;
        int id;
        public Bird(){

        }

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

    // 静态成员内部类
    static class Dog{
        String name;
        int id;
        public Dog(){

        }

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

        }
    }


    // 外部类的成员方法
    public void show(){
        System.out.println("我是外部类的show()方法");
    }
}

局部内部类:常常使用一个方法,使其返回值为某个类或接口的对象,而这个类或接口在方法内部创建。举例:

匿名内部类:

举例:

class OuterJu{

    // 局部内部类的使用
    public Comparable getComparable(){
        //1.创建一个实现Comparable接口的类:局部内部类
        class MyComparable implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        // 2. 返回一个实现类的对象
        return new MyComparable();
    }

    // 匿名内部类的使用
    public Comparable getComparable1(){
        //返回一个实现Comparable接口的匿名内部类的对象
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
}

细节

细节1

主函数会报错,因为无法访问非静态类,而且由于是静态不能采用this.new Inner()

方法:需要将Inner定义成静态类;

package java_demo_2;

/**
 * @ClassName: InnerClassDemo5
 * @author: benjamin
 * @version: 1.0
 * @description: TODO
 * @createTime: 2019/04/13/22:28
 */

public class InnerClassDemo5 {
    class Inner{// 如果不定义成静态,主函数会报错;

    }

    public static void main(String[] args) {

        new Inner(); //无法从静态上下文中引用非静态 变量 this
        // 因为主函数是静态的;
    }

    public void method(){
        
        new Inner(); // 正确
    }

    public static void show(Inter in){
        in.show1();
        in.show2();
    }
}

interface Inter{
    void show1();
    void show2();
}

细节2:

// 正确的
package java_demo_2;

public class InnerClassDemo6 {
    public static void main(String[] args) {

        new Outer6().method();
    }

}

class Outer6{

    // 创建的匿名内部类相当于
//    class Inner6 extends Object{
//        public void show(){
//            System.out.println("show run");
//        }
//    }
//    new Inner6.show();
    void method(){

        new Object(){
            public void show(){
                System.out.println("show run");
            }
        }.show();
    }
}

编译看左边

package java_demo_2;

public class InnerClassDemo6 {
    public static void main(String[] args) {

        new Outer6().method();
    }
}

class Outer6{

    void method(){

         Object obj = new Object(){
            public void show(){
                System.out.println("show run");
            }
         };
         obj.show();
//         Error:(35, 13) java: 找不到符号
        // 因为匿名内部类这个子类对象被向上转型为Object类型,
        // 这样就不再使用子类特有的方法了;
    }
}

java中的内部类

标签:return   事物   func   fun   create   int   匿名内部类   method   etc   

原文地址:https://www.cnblogs.com/benjieqiang/p/11512813.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!