黑马程序员——Java基础--多态、内部类、异常

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

多态、内部类、异常

一、多态
1、多态：可以理解为事物存在的多种体现形态。
例：动物中猫、狗
猫这个对象对应的类型是猫类型:猫 y = new 猫();
同时猫也是动物中的一种，也可以把猫称为动物。
动物 y = new 猫（）；
动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象。
2、多态的体现
  父类的引用指向了自己的子类对象。
  父类的引用也可以接收自己的子类对象。
3、多态的前提
  必须是类与类之间有关系，要么是继承，要么是实现。通常还有一个前提就是：存在覆盖。
4、多态的好处
  多态的出现大大的提高了程序的扩展性。
  弊端：
提高了扩展性，但是只能使用父类的引用访问父类中的成员。 
5、多态的应用

/*
需求：
动物
猫、狗
*/
abstract class Animal
{
	abstract void eat();	
}
class Cat extends Animal
{
	public void eat()
	{
		System.out.println("吃鱼");
	}
	public void catchMouse()
	{
		System.out.println("抓老鼠");
	}
}
class Dog extends Animal 
{
	public void eat()
	{
		System.out.println("吃骨头");
	}
	public void KanJia()
	{
		System.out.println("看家");
	}	
}

class Pig extends Animal
{
	public void eat()
	{
		System.out.println("饲料");
	}
	public void gongdi()
	{
		System.out.println("拱地");
	}
}
//------------------------------------------------------------
class DuoTaiDemo1
{
	public static void main(String[] args)
	{
		Animal a = new Cat();//类型提升。向上转型
		a.eat();
		//如果想要调用猫的特有方法时，如何操作？
		//强制将父类的引用，转成子类类型，向下转型。
		Cat c = (Cat)a;
		c.catchMouse();
/*
	千万不要出现这样的动作，就是将父类的对象转成子类类型。
<span style="white-space:pre">	</span>我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换
<span style="white-space:pre">	</span>多态自始至终都是子类对象做着变化。
		Animal a = new Animal();
		Cat c = (Cat)a;

<span style="white-space:pre">		</span>这是错误的
*/
		function(new Cat());
		function(new Dog());		
	}
	public static void function(Animal a)//Animal a = new Cat();
	{
		a.eat();
		//instanceof判断是否是cat的类型
		if(a instanceof Cat)
		{
			Cat c = (Cat)a;
			c.catchMouse();
		}
		else if(a instanceof Dog)
		{
			Dog c = (Dog)a;
			c.KanJia();
		}
	}
}

练习一：

/*
基础班学生：
	学习，睡觉
高级版学生：
	学习，睡觉

可以将这两类事物进行抽取。

*/
abstract class Student
{
	public abstract void study();
	public void sleep()
	{
		System.out.println("躺着睡");
	}
}
//单独封装操作学生的对象
class DoStudent
{
	public void doSome(Student stu)
	{
		stu.study();
		stu.sleep();
	}
}
class BaseStudent extends Student
{
	public void study()
	{
		System.out.println("base study");
	}
	public void sleep()
	{
		System.out.println("坐着睡");
	}
}
class AdvStudent extends Student
{
	public void study()
	{
		System.out.println("adv study");
	}
}

class DuoTaiDemo3
{
	public static void main(String[] args)
	{
		DoStudent ds = new DoStudent();
		ds.doSome(new BaseStudent());
		ds.doSome(new AdvStudent());


/*		BaseStudent bs = new BaseStudent();
		bs.study();
		bs.sleep();
		AdvStudent as = new AdvStudent();
		as.study();
		as.sleep();
*/
	}
}

6、在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
<*>面试环节--
在多态中，成员变量的特点：
无论编译和运行，都参考左边（引用应变量所属的类）。
在多态中，静态成员函数的特点：
无论编译和运行，都参考左边。

示例：

class Fu
{
	int num = 5;
	void method1()
	{
		System.out.println("fu method_1");
	}
	void method2()
	{
		System.out.println("fu method_2");
	}
	static void method4()
	{
		System.out.println("fu method_4");
	}
}
class Zi extends Fu
{
	int num = 8;
	void method1()
	{
		System.out.println("zi method_1");
	}
	void method3()
	{
		System.out.println("zi method_3");
	}
	static void method4()
	{
		System.out.println("zi method_4");
	}
}
class DuoTaiDemo4
{
	public static void main(String[] args)
	{
	/*	Fu f = new Zi();//多态编译时期
		System.out.println(f.num);
		Zi z = new Zi();
		System.out.println(z.num);
		f.method1();
		f.method2();
		//f.method3();
	*/
		Fu f = new Zi();
		f.method4();

/*		Zi z = new Zi();
		z.method1();
		z.method2();
		z.method3();
*/
	}
}

练习：

练习：
/*
需求：
电脑运行实例，
电脑运行基于主板。
*/

interface PCI
{
	public void open();
	public void close();
	
}
class MainBoard
{
	public void run()
	{
		System.out.println("mainboard run");
	}
	public void usePCI(PCI p)//PCI p = new NetCard()//接口型引用指向自己的子//类对象
	{
		if(p!=null)
		{
			p.open();
			p.close();
		}
	}

}
//复写接口全部方法
class NetCard implements PCI
{
	public void open()
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard close");
	}
}
class SoundCard implements PCI
{
	public void open()
	{
		System.out.println("Soundcard open");
	}
	public void close()
	{
		System.out.println("Soundcard close");
	}
}


/*
class MainBoard
{
	public void run()
	{
		System.out.println("mainboard run");
	}
	public void usePCI(PCI p)
	{
		if(p!=null)
		{
		p.open();
		p.close();
		}
	}
}

class NetCard
{
	public void open()
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard close");
	}
}
*/
class DuoTaiDemo5
{
	public static void main(String[] args)
	{
		MainBoard mb = new MainBoard();
		mb.run();
		mb.usePCI(null);
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
	}
}

二、Object

Object:是所有对象的直接或者间接父类，就是传说中的上帝。该类中定义的肯定是所有的对象都具备的功能。
Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义。
只要沿袭父类中的功能，建立自己特有的比较内容即可，这就是覆盖。
练习：

class Demo //extends Object
{
	private int num;
	Demo(int num)
	{
		this.num = num;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Demo))
			return false;
		Demo d = (Demo)obj;//转型
		return this.num == d.num;
	}
	public String toString()
	{
		return "demo:"+num;
	}

/*	public boolean compare(Demo d)
	{
		return this.num==d.num;
	}
*/
}
class Person
{

}

class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo d1 = new Demo(4);
		
		System.out.println(d1.toString());
		//Demo d2 = new Demo(6);

<span style="white-space:pre">		</span>//可以直接调用父类方法
		System.out.println(Integer.toHexString(d1.hashCode()));
		//Person p = new Person();

		//System.out.println(d1.equals(d2));
	}
}

三、内部类
将一个类定义在另一个类里面，对里面那个类就称为内部类（内置类，嵌套类）
1、内部类的访问规则：
a.内部类可以直接访问外部类中的成员，包括私有。
  之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，
  格式 外部类名.this
b.外部类要访问内部类，必须建立内部类对象。
访问格式：
a.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
格式：
外部类名.内部类名 变量名 = 外部类对象.内部类对象
Outer.Inner in = new Outer().new Inner();
b.当内部类在成员位置上，就可以被成员修饰符所修饰。
  比如，private：将内部类在外部类中进行封装。
   static：内部类就具备了static的特性。只能直接访问外部类中的static成员，出现了访问局限。
c.在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().function();
注意：当内部类中定义了静态成员，该内部类必须是static的。
      当外部类中的静态方法访问内部类时，内部类也必须是static的
当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部事物的内容。

lass Outer
{
	private  static int x = 3;

	static class Inner//静态内部类
	{
		//int x = 4;
		static void function()
		{
			//int x = 6;
			System.out.println("inner:"+x);
				
		}
	}
	static class Inner2
	{
		void show()
		{
			System.out.println("inner2 show");
		}
	}
	 
	public static void method()
	{
		Inner.function();
		new Inner2().show();


		/*System.out.println(x);
		Inner in = new Inner();
		in.function();*/
	}
}
class InnerClassDemo
{
	public static void main(String[] args)
	{
		Outer.method();
		//Outer.Inner.function();
		//new Outer.Inner().function();
		//Outer out = new Outer();
		//out.method();

		//直接访问内部类中的成员。
		//Outer.Inner in = new Outer().new Inner();
		//in.function
	}
}

/*
内部类定义在局部时，
1.不可以被成员修饰符修饰。
2.可以直接访问外部类中的成员，因为还持有外部类中的引用。
  但是不可以访问他所在的局部中的变量，只能访问被final修饰的局部变量。  
*/
class Outer
{
	int x = 3;
	void method(final int a)
	{  
		final int y = 4;
		class Inner
		{
			void function()
			{
				System.out.println(y);
			}
		}
		new Inner().function();
	}
}


class InnerClassDemo3
{
	public static void main(String[] args)
	{
		new Outer().method(5);
	}
}

2、匿名内部类;
a.匿名内部类其实就是内部类的简写格式。
b.定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
c.匿名内部类的格式：new 父类或者接口（）{定义子类的内容}
d.其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，可以理解为带内容的对象。
e.匿名内部类中定义的方法最好不要超过3个。

abstract class AbsDemo
{
	abstract void show();
}
class Outer
{
	int x =3;
	/*class Inner extends AbsDemo
	{
		void show()
		{
			System.out.println("show :"+x);
		}
	}*/
	public void function()
	{
		//new Inner().show();

	
		
		AbsDemo d = new AbsDemo()//多态，。，。，。
		{
			int num = 9;
			void show()
			{
				System.out.println("x="+num);
			}
			void abc()
			{
				System.out.println("haha ");
			}
		};
		d.show();
		//d.abc();//编译失败；
	
	}

}
class InnerClassDemo4
{
	public static void main(String[] args)
	{
		new Outer().function();
	}
}

四、异常
1、异常：就是程序中运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
a.对于严重的，java通过Error类进行描述。如：运行的类不存在或者内存溢出分等
对于Error一般不编写针对性的代码对其进行处理。
b.对于非严重的，java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。
无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。
Throwable
|--Error
|--Exception
2、异常的处理
java提供了特有的语句进行处理。
try
{
需要被检测的代码
}
catch(异常类 变量)
{
处理异常代码：（处理方式）
}
finally
{
一定会执行的语句；
}
3、对捕获到的异常对象进行常见方法操作。
a.String getMessage（）;获取异常信息
b.在函数上声明异常。便于提高安全性，让调用着进行处理，不处理编译失败。
4、对多异常的处理。
a.声明异常时，建议声明更为具体的异常，这样处理的可以更具体。
b.对方声明几个异常，就对应有几个catch块。不要定义多余的catch块,如果多个catch块中的异常出现继承 关系，父类异常catch块放在最下面。
建议在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句e.printStackTrace();也不要 简单的诛邪一条输出语句。

class Demo
{
	int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
<span style="white-space:pre">	</span>//在功能上通过throws的关键字声明了该功能有可能会出现问题
	{
		int[] arr = new int[a];
		System.out.println(arr[4]);
		return a/b;
	}
}
class ExceptionDemo1
{
	public static void main(String[] args)
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,0);
			System.out.println("x="+x);
		}
		catch(Exception e)//Exception e= new ArithmeticException e()
		{
			System.out.println("haha+"+e.toString());

			e.printStackTrace();//异常名称、异常信息、异常出现的位置
//其实jvm默认的异常处理机制，就是调用e.printStackTrace方法。打印异常的堆栈的跟踪信息
		}

/*	//声明几个异常，就catch几个异常
		catch(ArithmeticException e)
		{
			System.out.println(e.toString());
			System.out.println("除零了");
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			System.out.println("角标越界了");
		}
*/		
		System.out.println("over");
	}

}

5、自定义异常：
因为项目中会出现特有的问题。而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按 照java的对问题封装的思想。将特有的问题，进行自定义的异常封装——自定义异常。
需求：在本程序中，对于除数是-1，也视为错误的是无法进行运算的。那么就需要对这个问题进行自定义的 描述。
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch 处理。要 么在函数上声明让调用者处理。
一般情况下，函数内出现异常，函数上需要声明。
发现打印的结果中只有异常的名称，却没有异常的信息。
因为自定义的异常并没有定义信息。
如何自定义异常信息呢？
因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过super语 句，那么就可以直接通过getMessage方法获取自定义的异常信息。
自定义异常：
必须是自定义类继承Exception。
继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性，这个可抛性是Throwable这个 体系的独有特点。只有这个体系中的类和对象才可以被throws和throw操作。
throws和throw的区别：
throws使用在函数上。
throw只用在函数内。
throws后面跟的异常类，可以跟多个，用逗号隔开。
throw后跟的是异常对象。

class FuShuException extends Exception
{
	private int value;
	FuShuException(String msg,int value)
	{
		super(msg);
		this.value = value;
	}
	public int getValue()
	{
		return value;
	}


/*	private String msg;
	FuShuException(String msg)
	{
		this.msg = msg;
	}
	public String getMessage()
	{
		return msg;
	}
*/
}

class Demo
{
	int div(int a,int b)throws FuShuException
	{
		if(b<0)
		throw new FuShuException("出现了除数是负数的情况/by fushu",b);
//手动通过throw关键字抛出一个自定义异常现象

		return a/b;
	}
}
class ExceptionDemo2
{
	public static void main(String[] args)
	{
		Demo d = new Demo();
		try
		{
		int x = d.div(4,-1);
		System.out.println("x="+x);
		}
		catch(FuShuException e)
		{
			System.out.println(e.toString());
			//System.out.println("除数出现负数了");
			System.out.println("错误的负数是："+e.getValue());
		}
	
		System.out.println("over");
	}

}

6、RuntimeException

Exception中有一个特殊的子类异常RuntimeException运行时异常。
如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。
如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。
之所以不用在函数声明，是因为不需要让调用者处理。当该类异常发生，希望程序停止，因为在运行时， 出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
自定义异常时：如果该异常的发生，无法在继续进行运算。就让自定义异常继承RuntimeException。
对于异常分两种：
a.编译时被检测的异常
b.编译时不被检测的异常（运行时异常，RuntimeException以及其子类）

class FuShuException extends RuntimeException
{
	FuShuException(String msg)
	{
		super(msg);
	}
}

class Demo
{
	int div(int a,int b)
	{
		if(b<0)
			throw new FuShuException("除数是负数");
		if(b==0)
			throw new ArithmeticException("被零除了");
		return a/b;
	}
}
class ExceptionDemo3
{
	public static void main(String[] args)
	{
		Demo d = new Demo();
		int x = d.div(4,-3);
		System.out.println("x="+x);
		
		System.out.println("over");
	}

}
finally代码块：定义一定执行的代码。
通常用于关闭资源。

*/

class FuShuException extends Exception
{
	FuShuException(String msg)
	{
		super(msg);
	}
}

class Demo
{
	int div(int a,int b)throws FuShuException
	{
		if(b<0)
			throw new FuShuException("除数是负数");
		
		return a/b;
	}
}
class ExceptionDemo4
{
	public static void main(String[] args)
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,-1);
			System.out.println("x="+x);
		}
		catch(FuShuException e)
		{
			System.out.println(e.toString());
			return;
		}
		finally
		{
			System.out.println("finally");
	//finally里放的是一定会执行的代码。
		}
	
		System.out.println("over");
	}

}
/*
public void method()
{
	连接数据库；

	数据操作;//throw new SQLEException();数据库异常

	关闭数据库；//该动作，无论数据操作是否成功，一定要关闭资源。

	try
	{
		链接数据库；
		数据操作；//throw new SQLEException

	}
	catch
	{
		会对数据库进行异常处理；
		
	}
	finally
	{
		关闭数据库；
	}

}

7、异常在子父类覆盖中的体现
a.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的 子类.
b.如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
c.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发 生了异常，就必须要进行try处理，绝对不能抛。

class AException extends Exception
{
	
}
class BException extends AException
{
	
}
class CException extends Exception
{
	
}
/*
Exception
	|--AException
		|--BException
	|--CException
*/

class Fu
{
	void show()throws AException
	{

	}
	
}
class Test
{
	void function(Fu f)
	{
		try
		{
			f.show();
		}
		catch(AException e)
		{
	
		}		
	}
}


class Zi extends Fu
{
	void show()throws BException
	{
		Test t= new Test;
		t.function(new Fu());
	}
}

练习：

/*
有一个圆形和长方形。

都可以获取面积，对于面积如果出现非法的数值，视为是获取面积出现的问题。
问题通过异常来表示。

先要对着个程序进行基本设计。

*/
class NoValueException extends RuntimeException
{
	NoValueException(String message)
	{
		super(message);
	}	
}
interface shape
{
	void getArea();
}

class Rec implements shape
{
	private int len,wid;
	Rec(int len,int wid)//throws NoValueException
	{
		if(len<=0 || wid <=0)
			throw new NoValueException("出现非法值");
		this.len = len;
		this.wid = wid;
	}
	public void getArea()
	{
		System.out.println(len*wid);
	}
}
`
class Circle implements shape
{
	private int radius;
	public static final double PI = 3.14;
	Circle(int radius)
	{
		if(radius<=0)
			throw new NoValueException("非法");
		this.radius = radius;
	}
	public void getArea()
	{
		System.out.println(radius*radius*PI);
	}
}

class ExceptionTest
{
	public static void main(String[] args)
	{
		
		Rec r = new Rec(3,4);
		Circle c = new Circle(-8);
		r.getArea();
		c.getArea();
		System.out.println("over");
		
	}
}

五、包(Package)
对类文件进行分类管理。
给类提供多层命名空间
写在程序文件的第一行。
类名的全称是：包名.类名
包也是一中封装形式。
包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
不同包中的子类可以访问父类中被protected权限修饰的成员。
包与包之间可以使用的权限是有两种，public protected。
权限对比：
public protected default private
同一个类中 OK     OK   OK       OK
同一个包中 OK       OK     OK
子类 OK  OK
不同包中 OK