黑马程序员——java面向对象（三）多态、内部类、包

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、包

包的概述

其实就是文件夹

作用：对类进行分类管理

定义包的格式

package 包名;

多级包用.分开即可

注意事项：

package语句必须是程序的第一条可执行的代码

package语句在一个java文件中只能有一个

如果没有package，默认表示无包名

导包概述

不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。

导包格式

import 包名;

注意：

这种方式导入是到类的名称。

虽然可以最后写*，但是不建议。

二、内部类

内部类概述：

把类定义在其他类的内部，这个类就被称为内部类。

举例：在类A中定义了一个类B，类B就是内部类。

内部类的访问特点：

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

外部类要访问内部类的成员，必须创建对象。

内部类的访问规则

        1、内部类可以直接访问外部类中的成员，包括私有。

              之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：  外部类名.this。

        2、外部类要访问内部类，必须建立内部类对象。

局部内部类

可以直接访问外部类的成员

可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

局部内部类访问局部变量的注意事项：

局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

匿名内部类

就是内部类的简化写法。

前提：存在一个类或者接口

这里的类可以是具体类也可以是抽象类。

格式：

new 类名或者接口名() {重写方法;}

本质：

是一个继承了类或者实现了接口的子类匿名对象

匿名内部类在开发中的使用

首先回顾我们曾经讲过的方法的形式参数是引用类型的情况，重点是接口的情况，我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象，所以，可以使用匿名内部类改进以前的做法。

interface Person {
	public abstract void study();
}

class PersonDemo {
	//接口名作为形式参数
	//其实这里需要的不是接口，而是该接口的实现类的对象
	public void method(Person p) {
		p.study();
	}
}

//实现类
class Student implements Person {
	public void study() {
		System.out.println("好好学习,天天向上");
	}
}

class InnerClassTest2 {
	public static void main(String[] args) {
		//测试
		PersonDemo pd = new PersonDemo();
		Person p = new Student();
		pd.method(p);
		System.out.println("--------------------");
		
		//匿名内部类在开发中的使用
		//匿名内部类的本质是继承类或者实现了接口的子类匿名对象
		pd.method(new Person(){
			public void study() {
				System.out.println("好好学习,天天向上");
			}
		});
	}
}

三、多态

多态概述

某一个事物，在不同时刻表现出来的不同状态。

举例：

猫可以是猫的类型。猫 m = new 猫();

同时猫也是动物的一种，也可以把猫称为动物。

动物 d = new 猫();

在举一个例子：水在不同时刻的状态

多态前提和体现

有继承关系

有方法重写

有父类引用指向子类对象

多态分为两种：编译时多态和运行时多态。

                  编译时类型：主观概念，把它看作什么。

                  运行时类型：客观概念，实际它是什么。

                例：Animal a=new Dog();

                             指着狗问，这个动物是什么？

                            

            运行时多态的三原则：

                  对象类型不变。

                  只能对对象调用编译时类型中定义的方法。

                  在程序的运行时，根据对象的运行时类型，找覆盖后的方法来调用。（运行时动态类型绑定）

 强制类型转换： 一定没有新对象生成。(父类的引用赋值给子类的引用需要进行强制类型转换)

            关键字：instanceof

              用法：引用 instanceof  类名    判断这个引用所指向的对象是否属于这个类。

                用在强制转换之前，避免类型转换异常。

                           if(a instanceofDog){

                                    Dog d=(Dog)a;

                           }

                          

         多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

class Animal {
	public void eat(){}
}

class Dog extends Animal {
	public void eat() {}
	
	public void lookDoor() {
	
	}
}

class Cat extends Animal {
	public void eat() {
	
	}
	
	public void playGame() {
		
	}
}

class DuoTaiDemo5 {
	public static void main(String[] args) {
		//内存中的是狗
		Animal a = new Dog();
		Dog d = (Dog)a;
		
		//内存中是猫
		a = new Cat();
		Cat c = (Cat)a;
		
		//内存中是猫
		Dog dd = (Dog)a; //ClassCastException
	}
}