当前位置：首页 > article >正文

Java基础知识03(内部类)【24.11.25】

article 2024/11/16 15:58:15

类的5大成员:属性，方法，构造器，代码块，内部类

1.内部类的分类

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

1)局部内部类(有类名）

样例如下：

package com.temporary.mid_term;

class Outer1 {

    private int a = 1;

    public void m1(){
        System.out.println("方法m1被调用");
    };

    public void m2() {

        class Inner {

            public void f1() {
                m1();//直接调用
                System.out.println("a=" + a);
            }

//局部内部类可以访问外部类的所有成员，包括私有的}
        }//内部类结束
//创建对象
        Inner inner = new Inner();
        inner.f1();
        {//代码块也可以定义内部类}
        }
    }
}
public class Outer{
    public static void main(String[] args) {
        Outer1 outer = new Outer1();
        outer.m2();
    }
}

测试结果：

细节如下：

1.可以直接访问外部类所有成员

2.不能添加访问修饰符，相当于局部变量，但是可以用final修饰，就是不能用public，加了final就不能被继承

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

4.外部类可以创建局部类的对象，然后调用方法即可

5.外部其他类例如main不能访问局部内部类

6.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，可以使用(外部类名.this.成员)

例如我在内部类再次定义属性a=10,再调用时就是输出a=10，如果我一定要访问外部类的属性a;可以用Outer1.this.a的形式，谁调用了m1，谁就是Outer2.this

2）匿名内部类(Anonymous Class无类名）重点！！！

细节如下：

1.基本语法:new 类或接口（参数列表）

2.匿名内部类只使用一次

3.语法：

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

}；

测试用例：

package com.temporary.mid_term;

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer2 outer = new Outer2();
outer.method();

    }
}
  class Outer2<Amimal> {//外部类
        private int a = 10;
        public void method(){
            //基于接口的匿名内部类
            //想使用IA接口，传统方式就是写一个类实现该接口，创建对象
            //如果我只想实现一次的话比如Animal接口很多动物都要实现就得创建很多类很多
            //可以用内部类用来简化
            IA tiger = new IA() {
                //运行类型是匿名内部类，编译类型是IA
                @Override
                public void cry() {
                    System.out.println("匿名内部类重写了cry方法");
                }
            };
            System.out.println("tiger的运行类型=" + tiger.getClass());
            tiger.cry();//重写了要重新调用才能实现目的
            //基于类的匿名内部类
             Father father = new Father("jack"){
                 @Override
                 public void Test() {

                     System.out.println("匿名内部类重写了test方法");
                 }
             };//带分号
            System.out.println("father的运行类型=" + father.getClass());
            father.Test();
 Animal  animal = new Animal(){
     @Override
     public void eat() {
         System.out.println("小狗吃骨头");
     }
 };
 animal.eat();
            System.out.println(animal.getClass());


    }
    interface IA{
public void cry();
    }
    class Father{
public Father(String name){
    System.out.println("name=" + name);
}
public void Test(){
    System.out.println(123);}
    }
    //再定义一个抽象类
      abstract class Animal{
        public Animal() {
        }
//抽象方法中没有方法体
 abstract void eat();
    }

    }

3）成员内部类(没有static修饰）

简述：成员内部类式定义在外部类的成员位置，并且没有static修饰

细节：

1.可以直接访问外部类的所有成员，包括私有的

2.可以添加任意修饰符（四个）

3.作用域：成员内部类访问外部类成员（直接访问）,外部类访问成员内部类（创建对象再访问），外部其他类访问成员内部类：

Outer01 outer01 = new Outer01()；

Inner01 inner01 = outer01.new Inner01()；

//

Inner01 inner01 = new Outer().new Inner01()；

//使用一个方法获取

Inner inner01 = new Outer01().getInner01()；

代码样例：


public class Inner01 {//内部类
    private int n1 = 10;
    public String name = "张三";
    //成员内部类
    class Inner02{
        public void say(){
            System.out.println("n1=" + n1 + " ,name=" + name);
        }
    }
    //写方法
    public void t1(){
        Inner02 inner02 = new Inner02();
        inner02.say();
    }

}

4)静态内部类(使用static修饰）

介绍：静态内部类就是定义在外部类的所有静态成员，并且有static修饰

细节：

1.可以直接访问外部类的所有静态成员，包括私有的，但是不能直接访问非静态成员

2.可以访问任意修饰符，其地位就是一个成员

3.外部其他类怎么访问？？？

Outer01 .Inner01 j = new Outer01.inner01();//前提式满足访问权限，内部类不能私有