Java教程

java内部类

本文主要是介绍java内部类,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

内部类

首先讲一下类的五大成员:属性,方法,构造器,代码块,内部类。

内部类就是类中嵌套另外的类,内部类最大的特点就是可以直接访问私有属性,并且可以体现类与类中间的包含关系。

局部内部类

  1. 局部内部类定义在外部类的方法或者代码块中。
  2. 可以直接访问外部类的所有成员包括私有成员。
  3. 不能添加访问修饰符,但是可以使用final。
  4. 作用域:仅仅在定义它的方法或者代码块中。
  5. 外部类访问内部类需要在作用于内创建对象。
public class LocalInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();

    }
}

class Outer {
    private int n = 1;

    public void m3() {
        System.out.println("这是m3()方法。");
    }

    //在方法中或者代码块中写内部类。
    public void m1() {
        final class Inner {//不能添加访问修饰符,可以使用final修饰。

            public void m2() {
                System.out.println(n);
                m3();
            }

        } 
        //外部类在方法中,可以创建内部类对象,然后访问内部类的方法。
        Inner inner = new Inner();
        inner.m2();

    }
}

  1. 如果外部类和局部类有重名成员时,默认就近原则,如果想访问外部类的成员,则可以使用(外部类.this.成员)

    public class LocalInnerClass {
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.m1();
    
        }
    }
    
    class Outer {
        private int n = 1;//外部类的n。
    
        public void m3() {
            System.out.println("这是m3()方法。");
        }
    
        //在方法中或者代码块中写内部类。
        public void m1() {
            final class Inner {//不能添加访问修饰符,可以使用final修饰。
                  private int n=3;//内部类的n;
                public void m2() {
                    System.out.println(n);
                    System.out.println("外部类的n值是:"+Outer.this.n);//访问外部属性n。
                    m3();
                }
    
            }
            //外部类在方法中可以创建内部类对象,然后访问内部类的方法。
            Inner inner = new Inner();
            inner.m2();
    
        }
    }
    
    

匿名内部类

定义:本质是类,定义在外部类的局部位置(方法或者代码块中。)

为什么要使用匿名内部类?

因为有些类只是用一次,后面不再使用,所以用匿名内部类简化开发。

基本语法:new 类或者接口{

类体

};

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

class Outer {
    public void method() {
        //IB是编译类型,真正的的运行类型是匿名内部类Outer$1。
        IB tiger = new IB() {

            @Override
            public void cry() {
                System.out.println("Tiger叫唤。");
            }
        };
        tiger.cry();
        System.out.println(tiger.getClass());//class com.zj.AnonymousInnerClass.Outer$1,实际的匿名内部类类名,它是底层分配的,不显示。
    }
}
interface IB{
    void cry();

public class Anonymous02 {
    public static void main(String[] args) {
        Outer02 outer = new Outer02();
        outer.method();
    }
}
class Outer02{
    public void method(){
        Father father=new Father("张三"){

        };     
        Mother mother=new Mother() {
            @Override
            public void hello() {
                System.out.println("我是Hello.");
            }
        };
        mother.hello();
         System.out.println(father.getClass());
    }


}
class Father{
String name;
    public Father(String name){
        this.name=name;
        System.out.println("名字是:"+this.name);
    }
    public void hi(){

    }
}
abstract class Mother{
    abstract public void hello();
}
//名字是:张三
//class com.zj.AnonymousInnerClass.Outer02$1
//我是Hello.

注意细节

  1. 可以直接访问外部类的所有成员,包括私有的。
  2. 不能添加访问修饰符,因为它就是一个局部变量。
  3. 作用域仅仅在方法或者代码块中。
  4. 匿名内部类直接访问外部类成员。
  5. 外部其他类不能访问匿名内部类。
  6. (类似于局部内部类)如果外部类和内部类重名时,内部类访问的话默认就近原则,如果想访问外部类的成员,则可以使用(外部类.this.成员)

匿名内部类使用的实践:

public class AnonymousExercise02 {
    public static void main(String[] args) {
        CellPhone cellPhone = new CellPhone();
        CellPhone cellPhone1 = new CellPhone();
        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小猪起床了。");
            }
        });
        cellPhone1.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小可爱起床了。");
            }
        });
    }

}
interface Bell{
    void ring();
}
class CellPhone{
    public void alarmClock(Bell bell){
        System.out.println(bell.getClass());
        bell.ring();
    }
}
//class com.zj.AnonymousInnerClass.AnonymousExercise02$1
//小猪起床了。
//class com.zj.AnonymousInnerClass.AnonymousExercise02$2
//小可爱起床了。

成员内部类:

  1. 定义在外部类的成员位置上。
  2. 可以直接访问外部类的所有信息。
  3. 可以添加任何访问修饰符,因为它本身就是一个成员。
public class MemberInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.t1();
    }

}
class Outer{
    private int n=10;
    public String name="张三";
    //成员内部类。
    class Inner{
        public void say(){
            System.out.println("n="+n+",name="+name);
        }
    }
    public void t1(){
        Inner inner = new Inner();
        inner.say();
    }
}

外部其他类使用成员内部类的三种方式。

1.外部类的对象.new 内部类(语法记住就行。)

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.t1();
        //外部其他类访问成员内部类。
        Outer.Inner inner = outer.new Inner();
        inner.say();

    }

}
class Outer{
    private int n=10;
    public String name="张三";
    class Inner{
        public void say(){
            System.out.println("n="+n+",name="+name);
        }
    }
    public void t1(){
        Inner inner = new Inner();
        inner.say();
    }
}

2.写一个方法返回一个实例。

public class MemberInnerClass {
    public static void main(String[] args) {
        
        Outer.Inner instance = outer.getInstance();
        instance.say();

    }

}
class Outer{
    private int n=10;
    public String name="张三";
    class Inner{
        public void say(){
            System.out.println("n="+n+",name="+name);
        }
    }
    public Inner getInstance(){
        return new Inner();
    }
   
}

静态成员类

  1. 使用static修饰。

  2. 可以直接访问所有静态成员,但是不能访问非静态成员。

  3. 可以添加任何访问修饰符。因为它的地位相当于一个成员。

  4. 外部类访问内部类的方式。直接创建一个方法然后new对象再调用静态内部类的方法。

  5. 外部类和内部类成员重名时,默认就近原则。如果想访问外部类的成员用 外部类.成员。

    public class StaticInnerClass01 {
        public static void main(String[] args) {
            
            Outer outer = new Outer();
            outer.hi();
        }
    
    }
    class Outer{
        private int n=11;
        private static String name="张三";
        static class  Inner{
            public void say(){
                System.out.println("name= "+name);
            }
    
        }
        public void hi(){
            Inner inner = new Inner();
            inner.say();
        }
    }
    
    

    外部其他类调用静态内部类的方式。

    1. new 外部类.内部类()
    public class StaticInnerClass01 {
        public static void main(String[] args) {
            Outer.Inner inner = new Outer.Inner();
            inner.say();
          
        }
    
    }
    class Outer{
        private int n=11;
        private static String name="张三";
        static class  Inner{
            public void say(){
                System.out.println("name= "+name);
            }
    
        }
       
    }
    
    
    
    1. 写一个方法返回实例。

      public class StaticInnerClass01 {
          public static void main(String[] args) {
              //外部类调用
              Outer outer = new Outer();
              Outer.Inner instance = outer.getInstance();
              instance.say();
      
          }
      
      }
      class Outer{
          private int n=11;
          private static String name="张三";
          static class  Inner{
              public void say(){
                  System.out.println("name= "+name);
              }
      
          }
          //定义一个实例方法。
          public Inner getInstance(){
              return new Inner();
          }
      }
      
      
这篇关于java内部类的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!