Java学习~内部类 多继承 ，内部类的几种表现形式

类不可以多继承。

借助于内部类就可以实现类似于多继承的作用

//创建一个类 画家 Artist
public class Artist{ 
    public void hua(){
        System.out.println("画画");
    }
}

//创建一个 类 作家 writer
public class Writer{
    public void xie(){
        System.out.println("写作");
    }
}

public class Person{
//创建一个类 Person ，内部类 Man Woman 分别继承 Painter Weiter

    class Man extends Painter {

    }
    class Woman extends Writer{

    }


    public void huaA(){
        Man manA = new Man();
        manA .hua();
    }

    public void xieA(){
        Woman womanA = new Woman();
        womanA .xie();
    }

}

//main 方法实现
class Test{
    public static void main(String[] args) {
        Person person= new Person();
        person.huaA();
        person.xieA();
    }
}

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

 内部类的几种表现形式： 非静态内部类，局部内部类，匿名内部类，静态内部类。

一、非静态成员式内部类

定义：成员式内部类如同外部类的一个普通方法

成员式内部类有以下特性：

        1.持有父类引用，故可以访问父类任何访问权限的变量、方法

        2.非静态内部类中不能声明static成员

  上边的代码就是成员式内部类

如何访问非静态成员式内部类：

        外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

Person.Xiaoming xiaoming = new Person().new Xiaoming();

二、局部内部类（不常用）

定义：局部内部类就是定义在代码块、方法体内、作用域（{}）内的类。

 public class Person {
	//人在出生的时候选择性别
	private static String[] sex = {"男性","女性"};
	
	public void print() {
         
		class People {
			private String name = "xiaoming";
			public void print() {
       
				System.out.println("hello world"+sex[0]+name);
			}
		}
		People people = new People();
		people.print();
	}
}

public class Test {
	public static void main(String[] args) {
		
		Person person = new Person();
		person.print();
	}
}

局部内部类有以下特性：

        1.不能使用public、private、protected、static等这些修饰符

        2.局部内部类只能在当前方方法中使用，作用域范围仅限于当前方法中

        3.局部内部类和成员内部类一样，不能拥有静态成员，但可以访问外部成员的所有变量

        4.局部内部类访问的局部变量必须使用final修饰，在jdk8中自动隐式的加上了final

为什么不推荐使用局部内部类？

        如果当前方法不是main方法，那么当前方法调用完毕之后，当前方法的栈帧就会被销毁，方法内部的局部变量的空间也会被销毁。

三、匿名内部类

定义：匿名内部类是局部内部类的一种特殊形式，是一个没有名称的内部类。

注意：匿名内部类必须继承一个父类或者实现一个接口

//首先新建一个抽象类
public abstract class Person {
	 abstract  void sleep();
}

//继承这个抽象类并实现它的方法
public class Student  extends Person{
	
	private void sleep() {
		// TODO Auto-generated method stub
		System.out.println("学生在吃");
	}
	
}

//最后调用
public class Demo3 {
	public static void main(String[] args) {
		Person person = new Student();
		person.sleep();
	}
}

上方使用了多态的思想，将student类向上转型到person类当中，这里我们只是用了一次student类，使用匿名内部类可以 跳过这个student类来实现person当中的方法。

如此：

public class Demo3 {
	public static void main(String[] args) {
		new Person() {
			void sleep() {
				System.out.println("学生正在睡觉。。。。");
			};
		}.sleep();
	}
}

四、静态内部类

        定义：有时候，使用内部类只是为了把一个类隐藏在另一个类的内部，并不需要内部类引用外围类对象。为此，我们可以将内部类声明为static,以便取消产生的引用。

特点：

1.静态内部类在创建内部类实例的时候不必创建外部类实例。

OuterClass.InnerClass in = new OuterClass.InnerClass();

非静态内部类创建内部类示例

OuterClass.InnerClass in = new OuterClass().new InnerClass();

2.静态内部类可以直接访问外部类的静态成员

3.在静态内部类中可以定义静态和非静态的成员

4.外部类可以通过完整的类名直接访问静态内部类的静态成员。

public class OuterClass {
	String name = "Outer.name";
	static String name2 = "Outer.name2";
	static class InnerClass{
        static String name3 = "Inter.name3"
        private void printNmae() {
        // TODO Auto-generated method stub
        System.out.println(name2);
        System.out.println(new OuterClass().name);
        }
	}
}