Java 内部类可以调用其他类吗 java内部类是否可以被继承

java-内部类

概念：定义在另一个类中的类

所在位置：

package com.innerclass;

public class Person {
    private String[] sex={"男性","女性"};


    class XiaoMing{
        
    }
}

1、内部类意义

1. 内部类中的方法可以访问方法内部类所在的外部类中的数据，包括私有数据
2. 内部类可以对统一的数据隐藏起来，增强面向对象的封装性
3. 当想定义一个函数不想编写大量代码时，使用匿名内部类更加便捷
4. 借助内部类可以实现类的多继承

---

2、内部类作用

本身java不支持多继承，可以利用内部类实现：模拟实现多继承

一个类只能继承一个类，但是可以利用多个内部类，每个内部类继承一个类，可以模拟实现多继承的方法。

代码示例：

package com.innerclass;

import java.util.jar.JarEntry;

public class XiaoHua {

    class HuajiaA extends XiaoHua{
		public void xie(){
        	System.out.println("画画");
    	}
    }

    class ZuoJiaA extends XiaoHua{
		public void hua(){
       		System.out.println("写写");
    	}
    }

    public void hua(){
        HuajiaA huajiaA=new HuajiaA();
        huajiaA.xie();
    }

    public void xie(){
        ZuoJiaA zuoJiaA=new ZuoJiaA();
        zuoJiaA.hua();
    }

    public static void main(String[] args) {
        XiaoHua xiao=new XiaoHua();
        xiao.hua();
        xiao.xie();
    }
}

//输出
//画画
//写写

3、内部类的类型

1. 非静态内部类：非静态内部类如同外部类的一个对象方法（对象方法不能使用static）

• 持有隐士的父类引用，指向外部类对象的，故可以访问外部类任意访问权限的变量和方法
• 非静态内部类不能使用static
• 外部类.内部类 变量=new 外部类().new 内部类();
  例如：

Person.XiaoMing a=new Person().new XiaoMing();

class Outer{
	private int age = 10;//外部类 Outer.this.age
	public  void  testOuter(){
		System.out.println("Outer.testOuter()");
	}
	class Inter{
		int age = 20;//内部类 this.age
		public void show(){
			int age = 30;//局部变量 age
			System.out.println("外部类的成员变量age = "+Outer.this.age); //输出外部类
			System.out.println("内部类的成员变量age = "+this.age); //输出内部类
			System.out.println("局部变量age = "+age); //输出局部变量

		}
	}
}

----------------------------------------------------------------------------

   public static void main(String[] args) {
	   //创建内部类对象
	   Outer.Inter inter = new Outer().new Inter();//外部类以外的地方使用非静态内部类  
	  //new Inter()外部类中定义内部类
	   inter.show();//调用show()
   }

1. 局部内部类(不常用) : 局部内部类就是定义在代码块，方法体内，（{}）里面定义的类，都是局部内部类

• 不能使用public，private，static这些修饰符
• 局部内部类只能在当前方法中使用
• 局部内部类和非静态内部类一样，不能拥有静态变量，但是可以访问外部类的所有变量
• 局部内部类访问的局部变量必须使用final修饰,java8之后自动隐士的加上final
  局部内部类代码示例：

package com.innerclass;

public class Person {
    private String[] sex={"男性","女性"};

    
    public void test(){

        //没有被实例化之前，没有被new之前，都没有内存空间，不存在
        //局部内部类
        class People{    
            private String xiaoming_sex;

            String showSex(){  
                xiaoming_sex=sex[0];
                System.out.println(xiaoming_sex);
                return xiaoming_sex;
            }
        }

        People p = new People();  //只有当定义出来了之后才能new ，才能实例化
        p.showSex();
    }

    public static void main(String[] args) {

        Person p=new Person();
        p.test();


    }

1. 匿名内部类：是局部内部类的一种特殊形式，是一个没有名称的内部类,
   作用：省了一个类的定义，可以直接new 中声明出来，节省了代码量

• 匿名内部类使用条件：继承一个父类，或者实现一个接口

public interface Interface01 {
    void show();
}

//例：实现一个接口
---------------------------------
public static void main(String[] args) {
    Interface01 interface01 = new Interface01() {
        @Override
        public void show() {
            System.out.println("这里使用了匿名内部类");
        }
    };
    //调用接口方法
    interface01.show();
}

//匿名内部类
	 new Person(){
       @Override
       public void sleep(){
           System.out.println("学生睡觉");
       }
    }.sleep();

1. 静态内部类：静态内部类如同外部类的一个类方法：匿名内部类声明： static class InnterClass{}

• 静态内部类不能访问外部类的对象的变量和方法
• 静态内部类在创建内部类示例（对象）时不用创建外部类示例
• 静态内部类可以直接访问外部类的静态变量
• 静态内部类可以定义静态和非静态成员
• 外部类可以通过完整的类型直接访问静态内部类的静态成员
• 静态内部类代码示例：

package com.innerclass;

public class OutClass {

    //外部类的变量
    public static String name="张三";

    static class InnterClass{
        static String sex="男";

        public void test(){
            System.out.println(name);
        }
    }

    public static void main(String[] args) {
        InnterClass innterClass=new OutClass.InnterClass();
        innterClass.test();
		//外部类可以通过完整的类型直接访问静态内部类的静态成员
        System.out.println(OutClass.InnterClass.sex);   //输出男
    }

}