Java基础<七>--->抽象类、接口、内部类、异常等

第一 抽象类

一、概括：

       当多个类出现相同功能，但是功能主体不同是，这样就可以向上抽取，抽取时只抽取功能定义，而不抽取功能主体。这是我们就把抽取出来的功能主体因为没有具体的方法体，对于我们来说也就是看不懂的，用一个专业的词来形容就是抽象，抽象用一个特殊的关键字abstract来修饰，特别说明下类中有抽象方法时那么该类也就是抽象的，也必须用abstract来修饰。

二、抽象类的特点：

1、抽象方法一定在抽象类中。

2、抽象方法和抽象类都必须被abstract关键字修饰。

3、抽象类不可以用new创建对象。因为调用抽象方法没意义。

4、抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

总结：抽象类和一般类没有太大的不同。该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出来。但是无法定义主体，通过抽象方法来表示。特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

三、abstract 关键字，和哪些关键字不能共存。

1、final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。

2、private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。

3、static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。

四、抽象类中是否有构造函数？

有，抽象类是一个父类，要给子类提供实例的初始化。

/*
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。

员工类：name id pay

经理类：继承了员工，并有自己特有的bonus。


*/

class Employee
{
	private String name;
	private String id;
	private double pay;

	Employee(String name,String id,double pay)
	{
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	
	public abstract void work();

}



class Manager extends Employee
{
	private int bonus;
	Manager(String name,String id,double pay,int bonus)
	{
		super(name,id,pay);
		this.bonus = bonus;
	}
	public void work()
	{
		System.out.println("manager work");
	}
}

class Pro extends Employee
{
	Pro(String name,String id,double pay)
	{
		super(name,id,pay);
	}
	public void work()
	{
		System.out.println("pro work");
	}
}




class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

 第二 接口

一、概述：

接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。class用于定义类，interface 用于定义接口。

二、接口定义时，格式特点：

1、接口中常见定义：常量，抽象方法。

2、接口中的成员都有固定修饰符。

            常量：public static final

            方法：public abstract

记住：接口中的成员都是public的。

三、特点：

1、接口：是不可以创建对象的，因为有抽象方法。
2、需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
3、接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。接口与接口之间可以多继承。

interface Inter
{
	public static final int NUM = 3;
	public abstract void show();
}

interface InterA
{
	public abstract void show();
}

class Demo
{
	public void function(){}
}

class Test extends Demo implements Inter,InterA
{
	public void show(){}
}


interface A
{
	void methodA();
}
interface B //extends A
{
	void methodB();
}

interface C extends B,A
{
	void methodC();
}

class D implements C
{
	public void methodA(){}
	public void methodC(){}
	public void methodB(){}
}


class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		Test t = new Test();
		System.out.println(t.NUM);
		System.out.println(Test.NUM);
		System.out.println(Inter.NUM);

	}
}

说明：

1、类与类之间不能对继承，原因是多个父类中有同名函数，子类在运行的时候不知道运行那块代码。

2、java可以多实现，原因是接口都是抽象的，抽象方法没有方法体，不管有没有相同的函数，子类都只需要覆盖一次就可以了。

3、接口与接口之间可以多继承：因为接口中都是抽象方法，不存在方法体，也都需要子类去覆盖，所以不存在模糊的调用的。

四、接口的特点：

1、接口是对外暴露的规则

2、接口是程序的扩展功能

3、接口可以多实现

4、接口与接口之间可以多继承

5、接口降低了代码的耦合性

6、类与接口之间是实现关系，一个类可以继承一个类的同时去实现多个接口。

注意：两个或多个接口中不允许有返回值类型不同的同名函数

public class AB implements A, B {
	@Override
	public void method() {

	}

	public int method() {
		
	}

}

interface A {
	public abstract void method();
}

interface B {
	public abstract int method();
}

这代码是有错的，因为在类实现了两个接口后有两个方法名相同，但是返回值类型不同的方法，这是没有构成重载的，所以不能同时存在一个类中。

 第三 抽象类与接口的区别和联系

一、区别：

第一、与类的关系不同

1、抽象类是一种被子类继承的关系（类与类之间单继承）

2、接口与类之间是实现关系（一个类能实现多个接口）

3、接口与接口之间是继承关系（接口之间可以多继承）

第二、定义特点不同

1、抽象类可以定义变量、非抽象类、抽象类

变量：private、public、final、static等等修饰符

抽象方法：abstract(必须有)、public、static等等修饰符

2、接口可以定义常量、抽象类

常量：public static final（只能赋值一次）

方法：public abstract

3、权限不同：

抽象类可以有私有变量或方法（抽象方法不能为私有），子类继承抽象父类必须复写全部的抽象方法

接口是公开(public)的，里面不能有私有方法，因为接口是对外暴露的，是提供给外界使用的；实现接口必须重写接口中的全部抽象方法

4、成员不同：

抽象类中可以有自己的成员，也可以由非抽象的成员方法。

接口中只能有静态的不能被修改的成员变量（即常量），而且所有成员方法皆为抽象的。

5、变量不同：

抽象类中的变量默认是friendly型的，即包内的任何类都可以访问它，而包外的任何类都不能访问它(包括包外继承了此类的子类)，其值可以在子类中重新定义，也可重新赋值。

接口中定义的变量是默认的public static final，且必须进行初始化即赋初值，并不可改变。

二、联系

1.其实接口是抽象类的延伸，可以将它看做是纯粹的抽象类，就是说接口比抽象类还抽象。

2、抽象类和接口都必须被一个类（子类）复写里面的全部抽象方法。

3、接口和抽象类都不可创建对象，因为其中含有抽象方法，需要被子类实现后，对接口中抽象方法全覆盖后，子类才可以实现实例化。

第四 内部类

一、概述：

内部类，顾名思义就会定义在一个类里面的类就称为内部类。一个内部类可以定义在外部类的成员位置上，也可以定在函数内部作为局部存在。

二、内部类的访问规则：

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

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

三、访问格式：

1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。

格式
外部类名.内部类名  变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();

2、当内部类在成员位置上，就可以被成员修饰符所修饰。比如，private：将内部类在外部类中进行封装。static:内部类就具备static的特性。当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，如何直接访问static内部类的非静态成员呢？new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？uter.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。当外部类中的静态方法访问内部类时，内部类也必须是static的。

class Outer
{
	private static  int x = 3;

	
	static class Inner//静态内部类
	{
		static void function()
		{
			System.out.println("innner :"+x);
		}
	}

	static class Inner2
	{
		void show()
		{
			System.out.println("inner2 show");
		}
	}

	public static void method()
	{
		//Inner.function();
		new Inner2().show();
	}

}


class  InnerClassDemo2
{
	public static void main(String[] args) 
	{
		Outer.method();
		//Outer.Inner.function();
		//new Outer.Inner().function();
		//直接访问内部类中的成员。
//		Outer.Inner in = new Outer().new Inner();
//		in.function();
	}
}

四、内部类定义原则：

1、当描述事物是，事物的内部还有事物，则该事物用内部类来描述。如人与心脏的关系。

2、何时定义内部类：当一个类需要直接访问另一个的成员时，则将这个类放在另一个类的内部，并将此类封装。

局部内部类：当内部类只在外部类中的某个方法中，创建了这个类型的对象时，且仅使用了一次，那么可在这个方法中定义局部类。

注：

1、局部内部类不可用public或者private访问修饰符声明，它的作用域被限定在了声明这个局部类的代码块中

2、局部类的优势：

a.对外界完全隐藏，即使此方法所在的类也不可访问，也就是说，除此方法外，无任何方法知道它的存在。

b.可访问包含他们的外部类，因还持有外部类的引用；还可访问局部变量，但是局部变量必须被声明为final。

需要注意：局部内部类不可悲成员修饰符修饰，如static

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) 
	{
		Outer out = new Outer();
		out.method(7);
		out.method(8);
	}

}

在上面的代码中既传了7（out.method(7);）又传了8（out.method(8);）这是可以的，因为函数中的final int a是局部变量，加载在栈内存中，随着对象的消亡而消亡了。

五、匿名内部类：

1、匿名内部类其实就是内部类的简写格式。

2、定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

3、匿名内部类的格式：  new 父类或者接口(){定义子类的内容}

4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

5、匿名内部类中定义的方法最好不要超过3个。

abstract class AbsDemo
{
	abstract void show();
	
}


class Outer
{
	int x = 3;

	/*
	class Inner extends AbsDemo
	{
		int num = 90;
		void show()
		{
			System.out.println("show :"+num);
		}
		void abc()
		{
			System.out.println("hehe");
		}
	}
	*/

	public void function()
	{
		//AbsDemo a = new Inner();
//		Inner in = new Inner();
//		in.show();
//		in.abc();
	

		AbsDemo d = new AbsDemo()//new AbsDemo()匿名内部类的子类对象，多态
		{
			int num = 9;
			void show()
			{
				System.out.println("num==="+num);
			}
			void abc()
			{
				System.out.println("haha");
			}
		};

		d.show();
		//d.abc();//编译失败;不能向下转型
	}
}



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

练习：

interface Inter
{
	void method();
}

class Test 
{
	//补足代码。通过匿名内部类。
	/*
	static class Inner implements Inter
	{
		public void method()
		{
			System.out.println("method run");
		}
	}
	*/

	static Inter function()
	{
		return new Inter()
		{
			public void method()
			{
				System.out.println("method run");
			}
		};
	}

}



class InnerClassTest 
{
	public static void main(String[] args) 
	{

		//Test.function():Test类中有一个静态的方法function。
		//.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
		//因为只有是Inter类型的对象，才可以调用method方法。


		Test.function().method();
		

//		Inter in = Test.function();
//		in.method();


		show(new Inter()
		{
			public void method()
			{
				System.out.println("method show run");
			}
		});

	}

	public static void show(Inter in)
	{
		in.method();
	}
}

class InnerTest
{

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


	}
}

 第五 模版方法设计模式

什么是模版方法呢？
        在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。

/*
需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间并相减即可。

获取时间：System.currentTimeMillis();

当代码完成优化后，就可以解决这类问题。

这种方式，模版方法设计模式。



*/

abstract class GetTime
{
	public final void getTime()
	{
		long start = System.currentTimeMillis();

		runcode();

		long end = System.currentTimeMillis();

		System.out.println("毫秒："+(end-start));
	}
	public abstract void runcode();

}


class SubTime extends GetTime
{

	public void runcode()
	{
		
		for(int x=0; x<4000; x++)
		{
			System.out.print(x);
		}
	}
}


class  TemplateDemo
{
	public static void main(String[] args) 
	{
		//GetTime gt = new GetTime();
		SubTime gt = new SubTime();
		gt.getTime();
	}
}

 第六异常

一、异常概述：就是程序在运行时出现不正常情况。
二、异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

1、对于问题的划分：两种：一种是严重的问题，一种非严重的问题。

2、对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。

3、对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

    异常有两种：
编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
该异常被标识，代表这可以被处理。
运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。
该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

4、无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。

5、异常的好处：将问题进行封装；将正常流程代码和问题处理代码相分离，方便于阅读。

6、异常的注意事项：

     在子父类覆盖时：子类抛出的异常必须是父类的异常的子类或者子集；如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

三、异常的处理：

异常处理的任务：将控制权从错误产生的地方转移给能处理错误这种情况的错误处理器。

若函数上声明了异常，调用者需进行处理，处理方法可以throw，可以try。

1、对捕获的异常对象进行常见方法的操作：

trrows Exception：抛出异常

try-catch-finally：捕获异常 ---- java中提供了特有的语句进行处理。

String getMessage();获得异常信息

2、throw和throws的用法：

1）throw：定义在函数内，用于抛出异常对象。注：throw单独存在时，下面不要定义语句，因为执行不到，编译失败。

2）throws：定义在函数上，用于跑出异常类，可抛多个，用逗号隔开。

注：当函数内有throw抛出异常对象，必须给出对应的处理动作，若并未进行try处理，需在函数上声明，否则编译失败。

一般函数出现异常，需在函数上声明，但RuntimeException除外，若在函数内抛出此异常，函数上可不声明。

3、异常处理语句：

结合方式：

① try-chatch   ②try-finally  ③try-catch-finally

注：

①、在函数上声明异常：便于提高安全性，让调用者进行处理，若不处理，则编译失败。

②、finally中定义的通常为：关闭资源代码，因为资源必须被释放。

③、有一种情况不会执行finally，即出现System.exit(0);这条语句，后面的finally不会执行，因为这个代表系统退出吗，JVM结束。

4、多异常的处理：

1）声明异常时，建议声明更为具体的异常，这样处理更具体。

注：抛出几个具体的问题处理时，就具体处理哪些问题，而不是再加上catch(Exception e){...}让JVM自己将问题解决后再继续运行，那么调用者将不知道发生了什么问题。

2）原则：

对方声明几个异常，就对应几个catch块，不要定义多余catch，若多个catch块中的异常出现继承关系，父类异常catch块，放最下面（最大，处理更多）。

3）建议：

在进行catch处理时，catch中一定要定义具体处理方式，不要简单的定义一句：e.printStatckTrace();，也不要简单的打印一句。

遇到异常要怎么处理呢？常规做法是不打印异常信息，因为即时打印了，用户也无法解决掉，最好是将问题或信息记录下来，并存储为异常日志文件，便于程序员管理查阅，并及时修正代码，管理程序。

四、自定义异常：

1、概述：

因为项目中会出现特有问题，而这些问题并未被java所描述并封装成对象，所以这些特有问题可按java中对问题封装的思想，将特有问题进行定义的异常封装。

2、一般继承Exception或RuntimeException的原因：

1）异常体系有一个特点：异常类和异常对象都被抛出，他们都具有可抛性。这个可抛性是Throwable这个体系单独有的特点，只有此体系中的类和对象才可被throws和throw操作。

2）为了让该类具备操作异常的共性方法。

3、定义异常信息：

由于父类中把异常信息的操作完成了，所以子类只需要在构造函数时，将异常信息传递给父类，通过super语句，则可直接用getMessage方法，自动自定义的异常。

class FuShuException extends Exception //getMessage();
{
	private int value;

	FuShuException()
	{
		super();
	}
	FuShuException(String msg,int value)
	{
		super(msg);
		this.value = value;
	}

	public int getValue()
	{
		return value;
	}

}



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

		return a/b;
	}
}


class  ExceptionDemo3
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,-9);
			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");

	}
}

/*
class Throwable
{
	private String message;
	Throwable(String message)
	{
		this.message = message;
	}

	public String getMessage()
	{
		return message;
	}
}

class Exception extends Throwable
{
	Exception(String message)
	{
		super(message);
	}
}


class Person
{
	String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
		}
}

class Student extends Person
{
	Student (String name)
	{
		super(name);
	}
}

new Sttdent("lisi").getName();

*/

五、异常处理原则

1、处理方式：throw或throws

2、调用到抛出异常的功能时，抛几个，处理几个，一个try可以对应多个catch

3、多个catch，父类catch放在最下面。

4、catch内需要定义针对性的处理方式，不要定义printStackTrace，输出语句也不要不写，当捕获到异常，本功能处理不了时，可继续在catch中抛出

/*
毕老师用电脑上课。

开始思考上课中出现的问题。


比如问题是
	电脑蓝屏。
	电脑冒烟。

要对问题进行描述，封装成对象。


可是当冒烟发生后，出现讲课进度无法继续。

出现了讲师的问题：课时计划无法完成。


*/

class LanPingException extends Exception
{
	LanPingException(String message)
	{
		super(message);
	}
}

class MaoYanException extends Exception
{
	MaoYanException(String message)
	{
		super(message);
	}
}


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

class Computer
{
	private int state = 3;
	public void run()throws LanPingException,MaoYanException
	{
		if(state==2)
			throw new LanPingException("蓝屏了");
		if(state==3)
			throw new MaoYanException("冒烟了");

		System.out.println("电脑运行");
	}
	public void reset()
	{
		state = 1;
		System.out.println("电脑重启");
		
	}
}

class Teacher
{
	private String name;
	private Computer cmpt;

	Teacher(String name)
	{
		this.name = name;
		cmpt = new Computer();

	}

	public void prelect()throws NoPlanException
	{
		try
		{
			cmpt.run();			
		}
		catch (LanPingException e)
		{
			cmpt.reset();
		}
		catch (MaoYanException e)
		{
			
			test();
			throw new NoPlanException("课时无法继续"+e.getMessage());
			
		}
		System.out.println("讲课");
	}
	public void test()
	{
		System.out.println("练习");
	}

}



class ExceptionTest 
{
	public static void main(String[] args) 
	{
		Teacher t = new Teacher("毕老师");
		try
		{
			t.prelect();
		}
		catch (NoPlanException e)
		{
			System.out.println(e.toString());
			System.out.println("换老师或者放假");
		}
		
	}
}