Java总结-面向对象进阶

接口：
	它是一个特殊的抽象类。里面都是抽象方法。
	格式：
		通过interface来定义。
		该接口中的成员具备了特定的修饰符。
		成员包括：成员常量，和抽象方法。
		这些成员都是公有的。

		interface Demo
		{
			public static final int x = 3;
			pubilc abstract void show();
		}

	接口的出现将多继承这种机制通过多实现的方法体现。
	屏蔽了多继承出现的安全隐患。
	原理：因为接口中的方法都没有方法体。


	特点：
	1，接口的出现是一个对外暴露的规则。
	2，接口的出现给程序提高了功能扩展。
	3，接口的出现降低了程序间的耦合性。

	早期设计，为了扩展主板功能，可以将网卡焊在主板上，但是，虽然扩展了功能，耦合性却提高了。
	不方便与后期扩展。

	为了提高扩展性，降低主板和其他功能板卡的耦合性。
	定义了一个规则。主板只要使用这个规则即可。
	后期无论出现什么样的板卡，只要按照这个规则来制作主板都可以使用。

	这样降低了主板和板卡的耦合性，以及提高扩展性。


	主板的例子。
	interface PCI
	{
		void open();
		void close();
	}
	class MainBoard
	{
		/*useNetCard(NetCard nc)
		{

		}
		*/
		void usePCI(PCI p)//PCI p = new NetCard();
		{
			if(p==null)
				return;
			p.open();
			p.close();
		}
	}

	class Main
	{
		main()
		{
			MainBoard mb = new MainBoard();
			mb.usePCI(new NetCard());
		}
	}

	-------

	class NetCard implements PCI
	{
		public void open(){}
		public void close(){}
	}

	类与接口之间是实现关系，类与类之间是继承关系。
	接口与接口之间是继承关系，而且接口可以多继承。

	类可以在继承一个类的同时实现多个接口。

	abstract class Xueyuan
	{
		abstract void study();
		void sleep(){}
	}

	interface Smoke
	{
		void smoking();
	}

	class Zhangsan extends Xueyuan implements Smoke
	{
		void study(){}
		void smoking(){}
	}

------------------------------
多态：
	多种形态。
	在方法上有体现：重载，覆盖。
	在对象上也有体现。因为实例可以具备多种类型。
	在程序中的体现：父类或者接口的引用指向了自己的子类对象。

	多态的出现：提高了程序的扩展性。
	前提：  1，必须要有关系。
		2，出现覆盖操作。


	局限性：在通过多态设计时，不可以使用后期子类的特有方法。
	interface 动物
	{
		void shout();
		void move();
	}

	class 猫 implements 动物
	{
		public void shout()
		{
			System.out.println("喵喵");
		}
		public void move()
		{
			System.out.println("猫步 ");
		}
		public void 抓老鼠()
		{

		}
	}

	class 狗 implements 动物
	{
		public void shout()
		{
			System.out.println("汪汪");

		}
		public void move()
		{
			System.out.println("狗步");
		}
	}

	class 动物基本动作
	{
		void 动作(动物 z)
		{
			z.shout();
			z.move();
		}
	}

	main()
	{
		猫 x = new 猫();
		//x.shout();
		//x.move();
		动物基本动作 zz = new 动物基本动作();
		zz.动作(x);
		zz.动作(new 狗());


		//父类或者接口引用指向子类对象。
		动物 a = new 猫();//猫在向上转型。
		a.shout();
		a.move();

		show(a);

	}

	public static  void show(动物 x)
	{
		if(a instanceof 猫)
		{
		猫 c = (猫)a;//向下转型。
		注意：无论怎么转，自始至终都是子类对象在变化。
		c.抓老鼠();
		}
	}
	instanceof关键字：判断对象是否所属于指定的类或者接口。
	1，为了增强健壮性。
	2，如果子类是有限的，可以通过该关键性进行判断。

	面试示例：
	我就是一个对象，如果应聘到贵公司，我是就是员工的一种体现形态。
	//那么我回到家，就是孩子的一种体现形态。


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

Object对象：所有对象的父类。
	定义了所有对象都具备的方法：
	1，boolean equals(Object obj);判断两个对象是否相同。其实是在判断对象的地址值。
		return this==obj;
	2，String toString():所有对象都有字符串表现形式。
		结果是：类名@对象的哈希值。
		如果输出语句直接打印引用类型的实体，那么默认会调用toString()方法。
		Demo d = new Demo();
		System.out.println(d);
		System.out.println(d.toString());  

		return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
	3，Class getClass():获取对象所属的字节码文件对象。
	4，int hashCode():获取对象的哈希值，也就是在内存中的位置。

	5，void finalize():垃圾回收方法。是jvm自动调用。我们也可以手动调用一下。通过System.gc();
	注意：
	每一个对象都有可能有自己的判断对象相同的方法，以及对应的特有字符串表现形式。
	所以，通常都会复写Object类中的方法。定义已有功能的特有实现方式。



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

匿名内部类：
	其实就是内部类的一种简写形式 。
	格式：new 父类或者接口名(){}
	其实匿名内部类其实就是一个匿名的子类对象。这个对象有点胖。

	前提：
	1，内部类必须要继承外部其他类或者实现了外部接口。
	2，通常会有覆盖操作。
	interface Demo
	{
		void show();
	}

	class Outer
	{
		class Inner implements Demo
		{
			public void show(){}
		}

		void method()
		{
			new Inner().show();
		}
	}

	class Outer
	{
		void method()
		{
			new Demo()
			{
				public void show(){}
			}.show();
		}
	}


	class DemoImpl implements Demo
	{
		public void show(){}
	}

	class Outer
	{
		void method()
		{
			new DemoImpl().show();
		}
	}

	当一个类或者接口的子类，只需要创建一个对象调用成员时，也可以写成匿名内部类。


	abstract class Test
	{
		abstract void funca();
		abstract void funcb();
	}

	class Code
	{
		//补全代码。
		static Test method()
		{
			return new Test()
			{
				void funca(){}
				void funcb(){}
			};
		}
	}

	main()
	{
		Test t = Code.method();
		t.funca();
		t.funcb();
	}


	class Demo
	{

	}

	class DemoMain
	{
		void function()
		{
			new Demo()
			{
				public void show(){}
			}.show();
		}

		void method()
		{
			new Object()
			{
				public void show(){}
			}
		}
	}


	class ObjDemo
	{

		class Inner extends Object
		{
		}
		void method()
		{
			new Object()
			{
				void show()
				{
					System.out.println("haha");
				}
			}.show();
		}
	}

	class  ObjectInner
	{
		public static void main(String[] args) 
		{
			new ObjDemo().method();
		}
	}

	其实很简单，看多了，用多了，就习惯了。

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

	异常：
	程序运行时发生不正常情况。
	这种不正常情况，java对其进行描述。
	形成体系。
	一种是不需要处理的，Error，一种是可以处理的Exception。

	这两种也具备共性，比如，都给不正常情况定义了内容，都给不正常情况定义了名称。

	Throwable：异常和错误都具备可抛性。
		|--Error
			|--NoClassDefFoundError
		|--Exception
			|--RuntimeException
				|--NullPointerException
	常见方法：
		1，String getMessage():获取异常信息。
		2，String toString():异常对应的字符串表现形式：包含异常类名以及异常信息。
		3，void printStackTrace():打印异常在堆栈中的信息。
					包含：异常类名，异常信息。以及异常出现在程序中的位置。

	在定义功能时，可以在方法上通过throws关键字标识该功能因为参数的原因所发生不正常情况。
	以便于调用者进行处理。

	异常处理的两种方式：
	1，通过throws将异常抛出。
		如果不断的抛出，最终会被jvm的默认异常处理机制完成处理，但是程序会停止。
	2，通过try catch finally，完成对异常的处理。