面向对象（下）

第三章 面向对象（下）

一、接口

1.什么是接口

1.当类中方法全是抽象的，那么可以将该类定义成接口，用关键字interface定义。

2.接口的特点

1.接口中包含的成员，最常见的有全局常量、抽象方法。
2.接口中的成员都有固定的修饰符
a)成员变量：public static final 
b)成员方法：public abstract 

3.接口中有抽象方法，说明接口不可以实例化。接口的子类必须实现了接口中所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
4.类与类之间存在着继承关系，类与接口中间存在的是实现关系,继承用extends ,实现用implements ；
5.接口和类不一样的地方，就是，接口可以被多实现，这就是多继承改良后的结果。java将多继承机制通过多现实来体现。 
6.一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。
7.其实java中是有多继承的。接口与接口之间存在着继承关系，接口可以多继承接口。

3.抽象类与接口

1)抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取，特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。
2)接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。
3)抽象类和接口的共性：都是不断向上抽取的结果。
4)抽象类和接口的区别：
a)抽象类只能被继承，而且只能单继承。接口需要被实现，而且可以多实现。 
b)抽象类中可以定义非抽象方法，子类可以直接继承使用。接口中都有抽象方法，需要子类去实现。 
c)抽象类的成员修饰符可以自定义。接口中的成员修饰符是固定的。全都是public的。

二、多态

1.什么是多态

1)函数本身就具备多态性，某一种事物有不同的具体的体现。

2.多态的特点

1)父类引用或者接口的引用指向了自己的子类对象。

2)多态的好处

a)提高了程序的扩展性
3)多态的弊端

当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)
4)多态的前提
a)必须要有关系，比如继承、或者实现。
b)通常会有覆盖操作。
5)多态的出现思想上也做着变化

a)以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。

class 毕姥爷{
	void 讲课(){
		System.out.println("企业管理");
	}
	void 钓鱼(){
		System.out.println("钓鱼");
	}
}
class 毕老师 extends 毕姥爷{
	void 讲课(){
		System.out.println("JAVA");
	}
	void 看电影(){
		System.out.println("看电影");
	}
}
class {
	public static void main(String[] args) {
		毕姥爷 x = new 毕老师(); //毕老师对象被提升为了毕姥爷类型。 
		x.讲课();
		x.看电影();  //错误.
		毕老师 y = (毕老师)x; //将毕姥爷类型强制转换成毕老师类型。 
		y.看电影();//在多态中，自始自终都是子类对象在做着类型的变化。
	}
}

3.如何判断对象是哪个具体的子类类型

1)通过一个关键字 instanceof ,判断对象是否实现了指定的接口或继承了指定的类
2)格式

<对象 instanceof 类型> ，判断一个对象是否所属于指定的类型。
Student instanceof Person = true;//student继承了person类

4.多态在子父类中的成员上的体现的特点

1)成员变量：在多态中，子父类成员变量同名。
a)在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）
b)运行时期：也是参考引用型变量所属的类中是否有调用的成员。
c)无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。
d)就是成员变量编译运行都看左边。
2)成员函数
a)编译时期：参考引用型变量所属的类中是否有调用的方法。
b)运行事情：参考的是对象所属的类中是否有调用的方法。
c)在子父类中，对于一模一样的成员函数，有一个特性：覆盖。
d)成员函数，编译看引用型变量所属的类，运行看对象所属的类。
e)就是成员函数编译看左边，运行看右边。
3)静态函数 
a)编译时期：参考的是引用型变量所属的类中是否有调用的成员。
b)运行时期：也是参考引用型变量所属的类中是否有调用的成员。
c)静态方法，其实不所属于对象，而是所属于该方法所在的类。
d)调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。
e)静态函数编译运行都看左边。

5.Object类

1)所有类的直接或者间接父类，Java认为所有的对象都具备一些基本的共性内容，这些内容可以不断的向上抽取，最终就抽取到了一个最顶层的类中的，该类中定义的就是所有对象都具备的功能。
2)具体方法
a)boolean equals(Object obj)：用于比较两个对象是否相等，其实内部比较的就是两个对象地址。而根据对象的属性不同，判断对象是否相同的具体内容也不一样。所以在定义类时，一般都会复写equals方法，建立本类特有的判断对象是否相同的依据。

	public boolean equals(Object obj){
		if(!(obj instanceof Person))
			return false;
		Person p = (Person)obj;
		return this.age == p.age;
	}

b)String toString()：将对象变成字符串；默认返回的格式：类名@哈希值 = getClass().getName() + '@' + Integer.toHexString(hashCode())为了对象对应的字符串内容有意义，可以通过复写，建立该类对象自己特有的字符串表现形式。 

	public String toString(){
		return "person : "+age;
	}

c)Class getClass()：获取任意对象运行时的所属字节码文件对象。
d)int hashCode()：返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。
通常equals，toString，hashCode，在应用中都会被复写，建立具体对象的特有的内容。

三、内部类

1.什么是内部类

如果A类需要直接访问B类中的成员，而B类又需要建立A类的对象。这时,为了方便设计和访问，直接将A类定义在B类中。就可以了。A类就称为内部类。内部类可以直接访问外部类中的成员。而外部类想要访问内部类，必须要建立内部类的对象。

class Outer{
	int num = 4;	
	class  Inner {
		void show(){
			System.out.println("inner show run "+num);			
		}
	}
	public void method(){
		Inner in = new Inner();//创建内部类的对象。
		in.show();//调用内部类的方法。 
	}
}

1)直接访问内部类格式：外部类名.内部类名 变量名 =  外部类对象.内部类对象,Outer.Inner in = new Outer.new Inner();
2)私有修饰符:通常内部类被封装，都会被私有化，因为封装性不让其他程序直接访问。 
3)静态修饰符:如果内部类被静态修饰，相当于外部类，会出现访问局限性，只能访问外部类中的静态成员。
4)注意:如果内部类中定义了静态成员，那么该内部类必须是静态的。
5)为什么内部类可以直接访问外部类中的成员呢
a)那是因为内部中都持有一个外部类的引用。这个是引用是 外部类名.this 
b)内部类可以定义在外部类中的成员位置上，也可以定义在外部类中的局部位置上。
c)当内部类被定义在局部位置上，只能访问局部中被final修饰的局部变量。

2.匿名内部类

1)没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。
2)匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。
3)匿名内部类的使用场景：当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。

class Outer{
	int num = 4;	
	class  Inner {
		void show(){
			System.out.println("inner show run "+num);			
		}
	}
	public void method(){
		Inner in = new Inner();//创建内部类的对象。
		in.show();//调用内部类的方法。 
	}
}

四、异常

1.什么是异常

1)异常就是不正常，程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，问题出现的位置，所以可以不断的向上抽取。形成了异常体系。 

2.Throwable类

1)Throwable：可抛出的。 
2)Error：错误，一般情况下，不编写针对性的代码进行处理，通常是jvm发生的，需要对程序进行修正。
3)Exception：异常，可以有针对性的处理方式
4)无论是错误还是异常，它们都有具体的子类体现每一个问题，它们的子类都有一个共性，就是都以父类名才作为子类的后缀名。这个体系中的所有类和对象都具备一个独有的特点；就是可抛性,可抛性的体现：就是这个体系中的类和对象都可以被throws和throw两个关键字所操作。

5)处理方式有两种

a)捕捉

b)抛出
6)对于捕捉：java有针对性的语句块进行处理。

try {
	需要被检测的代码；
}
catch(异常类 变量名){
	异常处理代码；
}
fianlly{
	一定会执行的代码；
}

7)异常处理原则：

a)功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块，这样的处理有针对性，抛几个就处理几个。
b)特殊情况：try对应多个catch时，如果有父类的catch语句块，一定要放在下面。
8)throw 和throws关键字的区别：
a)throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。
b)throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。
c)通常情况：函数内容如果有throw，抛出异常对象，并没有进行处理，那么函数上一定要声明，否则编译失败。但是也有特殊情况。
9)异常分两种：
a)编译时被检查的异常，只要是Exception及其子类都是编译时被检测的异常。
b)运行时异常，其中Exception有一个特殊的子类RuntimeException，以及RuntimeException的子类是运行异常，也就说这个异常是编译时不被检查的异常。
10)编译时被检查的异常和运行时异常的区别：
a)编译被检查的异常在函数内被抛出，函数必须要声明，否编译失败。
b)声明的原因：是需要调用者对该异常进行处理。
c)运行时异常如果在函数内被抛出，在函数上不需要声明。
d)不声明的原因：不需要调用者处理，运行时异常发生，已经无法再让程序继续运行，所以，不让调用处理的，直接让程序停止，由调用者对代码进行修正。
11)定义异常处理时，什么时候定义try，什么时候定义throws呢？
a)功能内部如果出现异常，如果内部可以处理，就用try；
b)如果功能内部处理不了，就必须声明出来，让调用者处理。
12)自定义异常：当开发时，项目中出现了java中没有定义过的问题时，这时就需要我们按照java异常建立思想，将项目的中的特有问题也进行对象的封装。这个异常，称为自定义异常。
13)自定义异常的步骤：
a)定义一个子类继承Exception或RuntimeException，让该类具备可抛性。
b)通过throw 或者throws进行操作。
14)当异常出现后，在子父类进行覆盖时，有了一些新的特点
a)当子类覆盖父类的方法时，如果父类的方法抛出了异常，那么子类的方法要么不抛出异常要么抛出父类异常或者该异常的子类，不能抛出其他异常。
b)如果父类抛出了多个异常，那么子类在覆盖时只能抛出父类的异常的子集。
c)如果父类或者接口中的方法没有抛出过异常，那么子类是不可以抛出异常的，如果子类的覆盖的方法中出现了异常，只能try不能throws。
d)如果这个异常子类无法处理，已经影响了子类方法的具体运算，这时可以在子类方法中，通过throw抛出RuntimeException异常或者其子类，这样，子类的方法上是不需要throws声明的。
15)常见异常：
a)脚标越界异常（IndexOutOfBoundsException）包括数组、字符串；
b)空指针异常（NullPointerException）
c)类型转换异常：ClassCastException
d)没有这个元素异常：NullPointerException
e)不支持操作异常；

3.Import - 导入

1)类名称变长，写起来很麻烦。为了简化，使用了一个关键字：import，可以使用这个关键字导入指定包中的类。记住：实际开发时,到的哪个类就导入哪个类，不建议使用*.
import packa.*;//这个仅仅是导入了packa当前目录下的所有的类。不包含子包。
2)如果导入的两个包中存在着相同名称的类。这时如果用到该类，必须在代码中指定包名。
3)常见的软件包:
a)java.lang : language java的核心包，Object System  String Throwable jdk1.2版本后，该包中的类自动被导入。
b)java.awt : 定义的都是用于java图形界面开发的对象。
c)javax.swing: 提供所有的windows桌面应用程序包括的控件,比如：Frame , Dialog, Table, List 等等,就是java的图形界面库。
d)java.net : 用于java网络编程方面的对象都在该包中。
e)java.io : input  output 用于操作设备上数据的对象都在该包中。比如：读取硬盘数据，往硬盘写入数据。
f)java.util : java的工具包，时间对象，集合框架。
g)java.applet: application+let 客户端java小程序。server+let  -->  servlet 服务端java小程序。