Java日记（9）

内部类特点：

内部类可以很好的实现隐藏，可以使用protected private修饰符

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

外部类不能直接访问内部类的成员，必须首先建立内部类的对象才能访问

成员内部类访问外部类的成员方法和属性，要使用“外部类名.this.成员方法”和“外部类名.this.成员属性”的形式；创建成员内部类的实例使用“外部类名.内部类名 实例 = 外部类实例名.new 内部类构造方法（参数）”的形式。

class Outer
{
	int data;
	void printData()
	{
		System.out.println("外部类");
	}
	//外部类如何调用内部类
	void intitInner(int data)
	{
		i = new Inner();
		i.data = data;
	}
	void visitInner()
	{
//		Inner i = new Inner();
//		i.data = 15;
		System.out.println("内部类的data="+i.data);
	}
	class Inner
	{
		int data;
		void InnerPrint()
		{
			System.out.println("内部类");
			//内部类如何调用外部类的方法
			Outer.this.printData();
			System.out.println("外部类data="+Outer.this.data);
		}
	}
	Inner i;
}
public class NeiBuLei {
	public static void main(String[] args) {
		//内部类的实例使用
		Outer out = new Outer();//先实例好外部类
		Outer.Inner test = out.new Inner();//再实例内部类
		out.data = 12;
		out.intitInner(30);
		out.visitInner();
//		out.printData();
//		out.visitInner();
//		test.InnerPrint();
	}
}

匿名内部类：

abstract class Demo1
{
	abstract void printInfo();
}
public class Test {
	public static void main(String[] args) {
		new Demo1()
		{
			void printInfo()
			{
				System.out.println("这是匿名内部类1");
			}
		}.printInfo();
		Demo1 d = new Demo1()//使用多态方法输出
		{
			void printInfo()
			{
				System.out.println("这是匿名内部类2");
			}
		};
		d.printInfo();
	}
}

多态：多态性是指同一个操作作用于某一类对象，可以有不同的解释，产生不同的执行结果

多态存在的三个必要条件

需要存在继承和实现关系

同样的方法调用而执行不同操作、运行不同代码（重写）

在运行时父类或者接口的引用变量可以引用其子类的对象

多态的作用

多态通过分离做什么和怎么做，从一个角度将接口和实现进行分离

多态消除了类型之间的耦合关系

多态的存在提高了程序的拓展性和后期的可维护性

对象的向上向下转型：向上转型安全，向下转型不安全；因为子类在继承父类时会继承父类所有属性和方法，还可以自己增加一些其他的属性或方法，这时若向下转型就会出现异常（可以通过instance来判断是否会有异常）。

abstract class Animal
{
	public String name;
	abstract public void eat();
}
class Dog extends Animal//多态存在需要有继承和实现关系
{	//多态存在需要有重写
	public void eat()//同一个操作作用于某一类对象，可以有不同的解释，产生不同的执行结果
	{
		System.out.println("这是狗");
	}
	public void sleep()
	{
		System.out.println("狗在睡");
	}
}
class Cat extends Animal
{
	public void eat()//同一个操作作用于某一类对象，可以有不同的解释，产生不同的执行结果
	{
		System.out.println("这是猫");
	}
}
public class Test {
	public static void main(String[] args) {
		Animal an1 = new Dog();//在运行时父类或者接口的引用变量可以引用其子类的对象
		Animal an2 = new Cat();//在运行时父类或者接口的引用变量可以引用其子类的对象
		Dog dog = new Dog();
		an1.eat();
		//an1.sleep();这样会报错，因为这属于向下转型
		dog.sleep();
		an2.eat();
		if(an1 instanceof Cat)//这里判断an1可不可以转为Cat
		{
			System.out.println("正常");
			Cat cat = (Cat)an1;
			cat.eat();
		}
	}
}

多态小任务——打印机：

class School
{
	public Dayin iprint;
	public void install(Dayin iprint){
		this.iprint = iprint;
	}
	public void print(String context){
		iprint.print(context);
	}
}
class Dayin
{
	public String name;
	public void print(String context){}
}
class Colorprint extends Dayin
{
	public void print(String context){
		System.out.println("彩色打印"+context);
	}
}
class BWprint extends Dayin
{
	public void print(String context){
		System.out.println("黑白打印"+context);
	}
}
public class DaYin {
	public static void main(String[] args) {
		School s = new School();
		Colorprint color = new Colorprint();
		BWprint bw = new BWprint();
		s.install(color);
		s.print("dsghdfdsh");
		s.install(bw);
		s.print("dsghdfdsh");
	}
}