java笔记day10

面向对象

多态

对象的多态性

猫既具备猫的形态，又具备着动物的形态，这就是对象的多态性。

多态在代码中的体现：

父类或者接口的引用指向其子类的对象

class animal
{}
class cat extends animal
{}
cat x = new cat();
animal x = new cat();

多态的前提

1. 两个形态要有关系，继承或实现
2. 要有覆盖

转型

class Cat extends Animal
{
	void eat()
	{
		System.out.println("bone");
	}
	void play()
	{
		System.out.println("mouse");
	}
}
class{} main()
Animal e = new Cat();//自动类型提升（向上转型）：猫提升为了动物
e.eat();
//e.play();不能再执行这步操作，因为动物没有play的功能,如果这时候还想使用Cat的功能，可以将动物向下转型
Cat a = (Cat)e;
a.play();

类型判断

instanceof

public static void method(Animal a)
{
    a.eat();
    if(a instanceof Cat)//用于判断对象的具体类型，只能用于引用数据类型判断
    //通常在向下转型前用于健壮性的判断
    {
        Cat c = (Cat)a;
        c.play();
    }
}

成员变量

编译和运行都看左边

class Fu
{
	int num = 3;
}
class Zi
{
	int num = 4;
}
class {} main()		
		Zi z = new Zi();
		System.out.println(z.num);//输出为4
		Fu f = new Zi();
		System.out.println(f.num);//输出为3
		//简单说：编译和运行都参考等号左边，看引用型变量所属的类中是否有调用的成员变量num
	}
}

成员函数

编译看左边，运行看右边

class Fu
{
	void show()
	{
		System.out.println("Fu");
	}
}
class Zi extends Fu
{
	void show()
	{
		System.out.println("Zi");
	}
}
class {} main()
		Fu f = new Zi();
		f.show();
		//输出为Zi,对于成员函数，简单说：编译看左边，运行看右边，谁调用绑定谁（非静态）
	}
}

静态函数

对象才具有多态性，而静态函数不涉及对象，直接用类名调用。

内部类

将一个类定义在另一个类里面，里面的类就称之为内部类。

1. 内部类可以直接访问外部类中的成员
2. 外部类要访问内部类，必须建立内部类的对象

class Outer
{
	private int num = 6;
	class Inner
	{
		void show()
		{
			System.out.println("num="+num);
		}
	}
	public void method()
	{
		Inner a = new Inner();
		a.show();
	}
}

如何直接访问外部类中的内部类的成员？

Outer.Inner a = new Outer().new Inner();
a.show();
//如果内部类是静态的，相当于一个外部类
Outer.Inner a = new Outer.Inner();
a.show();

• 如果内部类中定义了静态成员，该内部类也必须是静态的。

局部内部类

• 内部类在局部位置上只能访问局部中被final修饰的局部变量

匿名内部类

匿名内部类就是内部类的简写格式。

前提：内部类必须继承或者实现一个外部类或者接口。

匿名内部类其实就是一个子类对象。

格式：new 父类或接口（）{内容}