java -内部类

最新推荐文章于 2024-09-14 18:46:05 发布

醉了这一生

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量151

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_50877151/article/details/120638298

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一个类的内部又完整的嵌入了另外一个类结构，被嵌入的类称为内部类，

嵌套其他类的类称外类，内部类最大特点可以直接访问其私有属性，并且可以体现类和类之间的包含关系。

底层源码中有大量内部类。

类的五大成员{属性，方法，构造器，代码块，内部类}

语法：

###### classOuLter{//外部类

	class Lnner{//内部类

	}

}

class Other{//外部其他类

}

分类

(1).定义在外部类局部位置上（比如方法内）：

1）局部内部类（有类名）

2）匿名内部类（无类名）

(2).定义在外部类的成员位置上：

1）成员内部类（没有static）

2）静态内部类（使用static）

一，局部内部类（有类名）

定义在外部类的局部位置，方法体或代码块，并且有类名。

1.局部内部类可以直接访问外部成员，包括私有。

2.不能添加访问修饰符，因为他的地位是一个局部变量，局部变量是不能添加修饰符的，可以添加final，添加final 后表示该类不能被继承。

3.作用域在定义它的方法或代码块中。

4.外部类访问局部内部类的成员，必须在内部类作用域内创建对象，在访问。

5.本质依然是一个类

public class Outor {
    public static void main(String[] args) {
    Animal animal=new Animal();
    animal.m2();
    }
}
class Sb{//外部其他类
    
}
class Animal {
    private int a = 1;

    private void age() {
        System.out.println(a + 100);
    }
    public void m2() {
        /* public class Pig ,error public not allowd here
        1.不能添加访问修饰符，可以添加final
        2.局部内部类是定义在外部类的局部位置，通常在方法
         */
         class Pig {//局部内部类
             //3.局部内部类可以直接访问外部成员包括私有
            public void Prin() {
                System.out.println(a + 99);
                age();
            }

        }
    //4.外部类访问局部内部类的成员，必须在内部类作用域内创建对象，在访问。
        Pig pig= new Pig();
         pig.Prin();
    }
}

6.外部其他类，不能访问，内部局部类，因为局部内部类地位是一个局部变量。

7.如果外部类和局部内部类的成员重名，默认遵守就近原则，如果想访问外部类成员可以用（外部类名.this.成员）去访问。

二，匿名内部类

(1).本质还是类，内部类，没有名字（其实有名字，不能直接看到，而是系统分配），同时还是一个对象

定义在外部类的局部位置，比如方法中且没有类名

语法：

new 类或接口（参数列表）{

类体

}；

引入：

public class animal {
    public static void main(String[] args) {
      Pig pig=new Pig();
      pig.say();
      tiger tiger_=new tiger();
      tiger_.say();
    }
}
interface IG{
    void say();
}
class Pig implements IG{

    @Override
    public void say() {
        System.out.println("pig。。。");
    }
}
class tiger implements IG{

    @Override
    public void say() {
        System.out.println("tiger。。。");
    }
}

由于class Pig ,class tiger 只用一次，后面不在使用，传统方式过于繁琐

为简化开发使用匿名内部类

public class Animal {
    public static void main(String[] args) {
        IG pig=new IG() {//基于接口的匿名内部类
            @Override
            public void say() {
                System.out.println("pig。。。");
            }
        };
        pig.say();
  		//只能用一次不能再次用IG tiger=new IG()//不会报错
        //后再通过tiger调用say()//error
    }
}
interface IG{
    void say();
}

此时Pig的编译类型为IG

Pig的运行类型为匿名内部类，并且名称为Animal$1(由系统命名)

在系统底层此处的

  IG pig=new IG() {
            @Override
            public void say() {
                System.out.println("pig。。。");
            }
        };

相当于

class Animal$1 implements IG{

    @Override
    public void say() {
        System.out.println("pig。。。");
    }

}

IG pig=new IG()

此处的new

jdk底层在创建匿名内部类Animal$1，后，立即创建Animal$1的实例，并且返回地址给pig

(2).匿名内部类即是一个类的定义，同时它本身也是一个对象，因此从语法上看，他既有定义类的特征，也有创建对象的特征

可以使用以下方法调用匿名内部类

class Pig {
    public  void fi(){
       new A() {
          @Override
          public void f2(){
			System.out.println("匿类内部类。。。");
          }
        }.f2();//调用方式1
    }
}
class A{
    public void f2(){
        System.out.println("A。。。");
    }
}

class Pig {
    public  void fi(){
       A a=new A() {
          @Override
          public void f2(){
          System.out.println("匿名内部类。。。");
          }
        };
       a.f2();//方式二
    }
}
class A{
    public void f2(){
        System.out.println("A。。。");
    }
}

匿名内部类实践

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

        f2(new SB() {
            @Override
            public void f1() {
                System.out.println("tiger tiger。。。");
            }
        });//企业这样使用更加简洁，此时匿名类的名称为Outor$1
    }
        public static void  f2(SB sb){
            sb.f1();

    }
}
interface SB{
    public  void f1();
}

成员内部类

(1).定义在外部类的成员位置，没有static 修饰

(2).可以直接访问外部类成员，包括私有。

(3).可以任意添加public private protect 默认访问修饰符，因为他地位就是一个成员

(4).作用域和其他类成员一样

(5).成员内部类访问外部类直接访问

(6).外部类访问内部类，先创建对象在调用

(7).外部其他类访问内部类

方式一：

A.A1 a1=A.new A1();

方式二

添加方法 public A get(){

return new A();

}//编写一个方法返回A对象

A.A1 a1=A.get();

(8).若外部类和内部类成员重名，遵循就进原则

如果想访问外部类成员使用（外部类.this.成员)

public class Outor {
    public static void main(String[] args) {
    A a=new A();
    a.f1();
    }
}
class A{
    private int i=5;
    public void say(){
        System.out.println("tiger tiger。。。");
    };
    class A1{//成员内部类
        public void hai(){
            System.out.println("pig pig。。。"+i);
        };
    }
    public void f1(){
        A1 a1=new A1();
        a1.hai();
    };
}

静态内部类

(1).定义在外部类的成员位置，有static 修饰

(2).可以直接访问外部类所有静态成员，包括私有。但不能直接访问非静态成员

(3).可以任意添加public private protect 默认访问修饰符，因为他地位就是一个成员

(4).作用域和类成员一样，为整个类体

(5).外部其他类访问静态内部类

方式一

A.A1 a1=new A.A1();//前提要有访问权限

方法二

编写一个方法返回A对象

public A get(){

return new A();

}//编写一个方法返回A对象

A.A1 a1=A.get();

(6).若外部类和内部类成员重名，遵循就进原则

如果想访问外部类成员使用（外部类.成员)

public class Outor {
    public static void main(String[] args) {
    A a=new A();
    a.f1();

    }
}
class A{
    private int i=5;
    static String name="wang";
    public void say(){
        System.out.println("tiger tiger。。。");
    };
    //静态内部类
    static class A1{
        public void hai(){
            System.out.println("pig pig。。。"+name);
        };
    }
    public void f1(){
        A1 a1=new A1();
        a1.hai();
    };
}