java面向对象之内部类（静态内部类、匿名内部类）

内部类：相当于在一个类只再定义一个类，如A类中定义一个B类，那么B类相对A类来说就称为内部类，A类相对于B类来说就是外部类

内部类分类：成员内部类、静态内部类、局部内部类、匿名内部类

import java.util.Scanner;

public class Main {
    public static void main (String[] args) {
    //创建外部类对象
    Oute ou=new Oute();
  
   //通过外部实例内部类
   Oute.Inner inn=ou.new Inner();
   inn.in();
   inn.getID();//通过内部类，调用
    
    
    }
}

class Oute {
    private int id;
    public void out(){
        System.out.println("外部类方法");
    }
    //定义内部类
    class Inner{
        public void in(){
            System.out.println("内部类方法");
        }
        //可以通过内部类获得外部类的私有属性和方法
        public void getID(){
           
            System.out.println(id);
        }
    }
}

静态内部类：

import java.util.Scanner;

public class Main {
    public static void main (String[] args) {
    //创建外部类对象
    Oute ou=new Oute();
  
   //通过外部实例内部类
   Oute.Inner inn=ou.new Inner();
   inn.in();
   inn.getID();//通过内部类，调用
    
    
    }
}

class Oute {
    private int id;
    public void out(){
        System.out.println("外部类方法");
    }
    //定义内部类静态内部类
    static class Inner{//因为是静态内部类，就不能直接像非静态内部类一样直接访问非静态属性和方法
        public void in(){
            System.out.println("内部类方法");
        }
        
    }
}

局部内部类：

public class Main {
    //局部内部类
    public void meth(){
        class In{//在方法中创建内部类
            
        }
    }
}

匿名内部类：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Appe().eat();
            //没有名字初始化接口，不用将实例保存到变量中
        new UserIp(){
            public void show(){
              
            }
        };
    }
}
class Appe{
    public void eat(){
        System.out.println("eat");
    }
}

interface UserIp{
    void show();
}

 

---

开发中局部内部类的使用：
package com.de.内部类;
/*
 *     开发中局部内部类的使用
 */
public class Nnukmwuk {
    //开发中很少见
        public void mabt() {
            //局部内部类
            class AA{
                
            }
        }
        
        //返回一个实现了Comparable接口类的对象
        public Comparable getComparable() {
            //创建一个实现了Comparable接口的类:局部内部类
            //方式一：
//            class MyComparable implements Comparable{
//
//                @Override
//                public int compareTo(Object o) {
//                    // TODO Auto-generated method stub
//                    return 0;
//                }
//                
//            }
//            return  new MyComparable();
            
            //方式二:创建了一个实现接口的匿名实现类的匿名对象
            return new Comparable() {

                @Override
                public int compareTo(Object o) {
                    return 0;
                }
                
            };
        }
}

局部内部使用的注意点：

 package com.de.内部类;

public class MwUko {
    /*+
     *     局部内部使用的注意点:
     * 在局部内部类的方法中（比如：htip（））如果 调用局部内部类所声明的方法（比如：）中的 局部变量的话
     *    要求此局部变量声明为final的
     *jdk4及之前的版本：要求此局部变量显式的声明为final的
     *jdk8及之后的版本：可以省略fial的声明
     */
    public void mead() {
        //局部变量
        final int num=10;//这个出了方法就不能用，如果内部类想用的话，他传过去的只是一个副本
        class AA{
            
            public void htip() {
                //num=20;
                System.out.println(num);//因为这个num他从外面 传进来的只一个副本，副本是不能修饰的，因为他只是复制了一个变量，外面是什么值他只能去用，不能去改
            }
        }
    }
}

使用：

代码：
package com.de.内部类;
/*
 *     类的内部成员之五：内部类
 * 1、java中允许将一个类A声明在一个类B中，则类A
 *     就是内部类，类B就是外部类
 * 2、内部类的分类：成员类部类(静态和非静态)vs局部内部类（方法内、代码块内、构造器内）
 * 3、成员内部类：
 *         一方面，作为外部类的成员：
 *             >调用外部类结构
 *             >可以被static修饰
 *            >可以被四种不同的权限修饰
 *        
 *
 *         另一方面，作为一个类：
 *             >类内可以定义属性、方法、构造器等
 *             >可以被final修饰，表示此类不能被继承，言外之意，就是不使用final就可以被继承 
 *             >可以被abstract修饰,(不能被实例化)
 * 
 * 
 * 4、关注如下的三个问题
 *     4.1、如何实例化成员内部类对象
 *     4.2、如何在成员内部中去区分调用外部类的结构
 *     4.3、开发中局部内部类的使用，见《Nnukmwuk》
 * 
 */
public class Mwukod {
public static void main(String[] args) {
    //创建一个DD的实例（静态的成员内部类）：
    perfa.DD f=new perfa.DD();
    f.htip();
    //创建一个EE实例（非静态的成员内部类）
//    perfa.EE d=new perfa.EE();这是错误的
    perfa a=new perfa();//因为他是非静态的所以要先创建他的外部对象才能创建他，
    perfa.EE bi=a.new EE();
    bi.kjsk();
    bi.wqvb("你好");
}
}
class perfa{
    
    String name="外部类";
    int age;
    public void htip() {
        
    }
    //成员内部类
    class ddey{
        
    }
    //静态成员内部类
     static class DD{
        String name;
        int age;
        public  void htip() {
            System.out.println("我想睡觉");
        }
    }
    //非静态成员内部类
     class EE{
        String name="内部类";
        public void kjsk() {
            System.out.println("我爱唱歌");
            perfa.this.htip();//调用外部非静态属性
        }
        public EE(){
            
        }
        public void wqvb(String name) {
            System.out.println(name);//方法形参
            System.out.println(this.name);//内部类的属性
            System.out.println(perfa.this.name);//perfa的属性，也叫外部类的属性
        }
    }
    
    public void metr() {
        //局部内部类
        class AA{
            
        }
        //局部内部类
        {
            class bb{
                
            }
            
        }
        
    }
    public perfa() {
        //局部内部类
        class CC{
            
        }
    }
}