04_面向对象（二）

七、final关键字

final:最终。作为一个修饰符，

1、可以修饰类，函数，变量。

2、被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。

3、被final修饰的方法不可以被覆盖。

4、final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。

当在描述数据时，一些数据出值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便阅读

而这些值不需要改变。加上final修饰。作为常量：所有的字母都大写。如果由多个单词组成，单词间由下划线连接。

5、内部类定义在类中局部位置上，只能访问被final修饰的局部变量。

八、抽象类

（1）、概念：当多个类出现相同功能，但是功能主体不同，这时候可以进行向上抽取，这时，只抽取功能定义，不抽取功能主体。

              抽象：看不懂

（2）、抽象类的特点：

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

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

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

            4、抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。

                  如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

（3）、注意：

            抽象类和一般类没有太大的不同。

            该怎么样描述事物就如何描述事物。只不过，该事物出现了一些看不懂的东西。

            这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。

            抽象类比一般类多个抽象函数。就是在类中可以定义抽象方法。

            抽象类不可以实例化。

            特殊： 抽象类中可以不定义抽象方法。这样做仅仅是不让该类建立对象。

（4）、模板方法设计模式：

            在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分。

            那么这个时候，不确定的部分暴露出去。由该类的子类去完成。

            获取程序运行时间。模板设计模式

public abstract class GetTime {public final void getTime() {long strattime = System.currentTimeMillis();runCode();long endtime = System.currentTimeMillis();}public abstract void runCode();}class SubTime extends GetTime {public void runCode() {// TODO Auto-generated method stubfor (int x = 0; x < 1000; x++) {System.out.println(x);}}}class Test {public static void main(String[] args) {GetTime g = new SubTime();g.getTime();}}

九、接口

（1）、初期理解：可以认为是一个特殊的抽象类。

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

interface 用于定义接口。

（2）、接口定义时,格式特点：

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

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

常量：public static final

方法：public abstract

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

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化

否则子类是一个抽象类。

接口可以被类多实现。

一个类可以实现多个接口。也是对多继承不支持的转换形式。java支持多实现。

接口与接口的关系：继承

interface A {void methodA();int show();}interface B {void methodB();}interface C extends B, A {void methodC();}class D implements C {public void methodA() {}public void methodC() {}public void methodB() {}public int show() {return 0;}}

（3）、接口的特点：

接口是对外暴露的规则。

接口是程序的功能扩展。

接口可以用来多实现。

类与接口之间是实现关系而且类可以继承一个类的同时实现多个接口。

接口与接口之间可以有继承关系。

public 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);}}interface Inter {public static final int NUM = 3;public abstract void show();}class Test implements Inter {public void show() {}}

十、多态

（1）、多态：可以理解为事物存在的多种体现形态。

public class DuotaiDemo {public static void main(String[] args) {Animal c = new Cat();//一个对象，多种形态c.eat();}}abstract class Animal {abstract void eat();}class Cat extends Animal {public void eat() {System.out.println("吃鱼");}}class Dog extends Animal {public void eat() {System.out.println("吃骨头");}}

（2）、多态的体现：

父类的引用指向了自己子类对象。

父类的引用也可以接收自己的子类的对象。

（3）、多态的前提：

必须是类与类之间有关系，要么继承，要么实现。

存在覆盖

（4）、多态的利与弊：

利：多态的出现大大提高了程序的扩展性。

弊：提高了扩展性，但是只能使用父类的引用访问父类中的成员。

public class DuotaiDemo {public static void main(String[] args) {function(new Cat());function(new Dog());}// 提高了代码的扩展性public static void function(Animal a) {a.eat();}}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("看家");}}

（5）、多态的应用：转型

Cat类中有一个特有的方法CatchMouse();

Animal a = new Cat();// 类型提升。向上转型a.eat();// 如果想要调用猫特有的方法时，如何操作？// 强制将父类引用，转成子类型。向下转型<pre name="code" class="java">                //我们能转换的是父类引用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。                //多态自始自终都是子类对象在做着变化。

Cat c = (Cat) a;c.catchMouse();// 千万不能出现这样的操作，就是将父类对象转成子类类型。// Animal a = new Animal();// Cat c = (Cat)a;

判断某一类型 引用指向的对象到底符合什么类型的时候

                if (a instanceof Cat) {Cat c = (Cat) a;c.catchMouse();} else if (a instanceof Dog) {Dog d = (Dog) a;d.kanJia();}

（6）、成员特点：

在编译时期：参阅引用型变量所属的类中是否有调用德尔方法。如果有，编译通过，没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：(非静态的)

无论编译和运行，都参考左边。（引用型变量所属的类）

父类有一个变量num,子类有一个变量num

Fu f=new Zi();

f.num是父类中的num;

Zi zi=new ZI();

zi.num是子类中的num;

在多态中静态成员函数的特点：

无论编译和运行，都参考左边。

类加载到内存，静态就存在了，不需要对象。

十一、Object

（1）、Object：是所有对象的直接或者间接父类，传说的上帝

（2）、特点：该类中定义的肯定是所有对象都具备的功能。

Object 类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同的功能，没有必要重新定义。

如果沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。

equals(); toString();

public class ObjectDemo {public static void main(String[] args) {Demo d1 = new Demo();Demo d2 = new Demo();Demo d3 = d1;System.out.println(d1.equals(d3));//比较的是地址符System.out.println(d1 == d2);System.out.println(d1 == d3);}}class Demo //extends Object{}

十二、内部类

（1）、定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

（2）、内部类的访问规则：

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

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

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

public class InnerClassDemo {public static void main(String[] args) {// Outer o=new Outer();// o.method();// 直接访问内部类的成员。Outer.Iner in = new Outer().new Iner();in.function();}}class Outer {private int x = 3;// 内部类可以私有化class Iner {int x = 4;public void function() {int x = 6;System.out.println("inner" + x);// 这里打印6，内部有的不往外找了System.out.println("inner" + this.x);// 这里打印4;System.out.println("inner" + Outer.this.x);// 这里打印6。。Outer.this可以省略}}public void method() {Iner i = new Iner();i.function();}}

（3）、访问格式：

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

      格式：外部类.内部类名 变量名=外部类对象.内部类对象;

2、当内部类在成员位置上，就可以被成员修饰符所修饰。

       比如private 将内部类在外部类中进行封装。

3、static ：内部类就具备static 的特性。

      当内部类被static 修饰后，只能直接访问外部类中的static成员了。出现了访问权限、

      在外部其他类中，如何直接访问static内部类的非静态成员呢？

      new Outer.Inner().function();;

      在外部其他类中，如何直接访问static内部类的静态成员呢？

      Outer.Inner.function();

（4）、注意：

当内部类中定义了静态成员，该内部类就必须是static的。

内部类定义规则。

（5）、用途：

当描述事物时，事物的内部还有事物，该事物用内部类来描述。

因为内部事物在使用外部事物的内容。

内部类只有定义在成员变量上的时候，才能被私有或者静态所修饰，一般内部类是不会被公有修饰的。

十三、匿名内部类

（1）、概念：在方法中定义内部类

（2）、特点：

a、不可以被成员修饰符修饰

b、可以直接访问外部类中的成员，因为还持有外部类的引用。

      但是不可以访问他所在的局部中的变量。只能访问被final修饰的局部变量

public class InnerClassDemo {public static void main(String[] args) {         Outer o=new Outer();         o.method(7);         o.method(6);}}class Outer {int x = 3;  void method(final int a) {  finalint y=4;/** * 此时不能被静态私有修饰，因为修饰符只能修饰成员，现在Inner在局部了，所以不能 * @author Administrator */class Inner {/** * 这里也不能用static修饰 */void function() {System.out.println(Outer.this.x);System.out.println(y);//加finalSystem.out.println(a);//加final}}new Inner().function();}}

（3）、注意：

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

b、定义匿名内部类的前提；

      内部类必须是继承一个类或者接口。

c、匿名内部类的格式，new 父类或者接口（）{定义子类的内容}

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

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

public class InnerClassDemo {public static void main(String[] args) {new Outer().function();}}class Outer {int x = 3;/* * class Inner extends AbsDemo{ void show(){ System.out.println("show:"+x); * } } */// 对上面的代码简化public void function() {// new Inner().show();/* * 整体是一个对象，是AbsDemo的一个子类对象，只有之类才能复写方法。 */new AbsDemo() {// 匿名内部类@Overridevoid show() {// 复写方法// TODO Auto-generated method stubSystem.out.println("x:" + x);}}.show();}}abstract class AbsDemo {abstract void show();}

十四、异常

（1）、异常：就是程序运行时出现的不正常情况。

（2）、异常的由来：

问题也是现实生活中的一个具体事物，也可以通过Java的类的形式描述，并封装成对象。

其实就是Java对不正常情况进行描述后的对象体现。

（3）、对异常的划分：

a、严重的问题，Java中用Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。

b、不严重的问题，Java中用Exception类进行描述。对于Exception可以使用针对性的代码对其进行处理。

（4）、异常的父类Throwable

无论是Error，还是Exception，都有一些共性的内容。比如不正常情况的信息、引发原因等。可以进行抽取，就出现了他们的父类Throwable

（5）、异常的处理：

Java提供了特有的语句对其进行处理。

Java异常机制主要依赖于try、catch、finally、throw、throws五个关键字。

1、try：它里面放置可能引发异常的代码

2、catch：后面对应异常类型和一个代码块，用于表明该catch块用于处理这种类型的代码块，可以有多个catch块。

3、finally：主要用于回收在try块里打开的物力资源（如数据库连接、网络连接和磁盘文件），异常机制总是保证finally块总是被执行。只有finally块，执行完成之后，才       会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。

4、throw：用于抛出一个实际的异常，可以单独作为语句使用，抛出一个具体的异常对象。

5、throws：用在方法签名中，用于声明该方法可能抛出的异常。

（6）、throws 和throw的区别：

1、throws使用在函数上。throw使用在函数内。

2、throws抛出的是异常类，可以抛出多个，用逗号隔开。throw抛出的是异常对象。

（7）、多异常处理

1、声明异常时，建议声明更为具体的异常。这样处理的也可以更为具体。

2、对方声明了几个异常，就应该对应几个catch块。

3、如果几个catch块出现了继承关系，父类异常catch应该放在最下边。

4、不要定义多余的catch块。