黑马程序员——Java语言--面向对象（二）

多态

定义

         某一类事物的存在多种形态。

例子

        动物中猫，狗。

        猫这个对象对应的类型是毛类型：猫 c = new 猫();

        同时猫也是动物中的一种，也可以把猫称为动物：动物 a  = new 猫();

        动物是猫和狗具体事物中抽取出来的父类型，父类型引用指向了子类对象。

简单说：就是一个对象对应着不同类型。

多态在代码中的体现：父类或者接口的引用指向其子类的对象。

abstract class Animal
{abstract void eat();
}class Dog extends Animal
{void eat(){System.out.println("啃骨头");}void seeHome(){System.out.println("看家");}
}class Cat extends Animal
{void eat(){System.out.println("吃鱼");}void catchMouse(){System.out.println("捉老鼠");}
}class Pig extends Animal
{void eat(){System.out.println("饲料");}void gongDi(){System.out.println("拱地");}
}class DuoTaiDemo 
{public static void main(String[] args) {Animal aCat = new Cat();Animal aDog = new Dog();Animal aPig = new Pig();eatMethod(aCat);eatMethod(aDog);eatMethod(aPig);}public static void eatMethod(Animal a){a.eat();}
}

多态的好处与弊端

好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。

弊端：前期定义的内容不能使用（调用）后期子类的特有内容。

多态的前提

1. 必须有关系，继承，实现。
2. 要有覆盖。
   

转型

例子：

abstract class Animal
{abstract void eat();
}class Dog extends Animal
{void eat(){System.out.println("啃骨头");}void seeHome(){System.out.println("看家");}
}class Cat extends Animal
{void eat(){System.out.println("吃鱼");}void catchMouse(){System.out.println("捉老鼠");}
}class Pig extends Animal
{void eat(){System.out.println("饲料");}void gongDi(){System.out.println("拱地");}
}class DuoTaiDemo 
{public static void main(String[] args) {/*  Animal aCat = new Cat();Animal aDog = new Dog();Animal aPig = new Pig();eatMethod(aCat);eatMethod(aDog);eatMethod(aPig); */Animal a = new Cat();// 一个对象，两种形态// 自动类型提升，猫对象提升成了动物类型。但是特有功能无法访问。// 作用就是限制对特有功能的访问// 专业讲：向上转型。a.eat();// 如果还想用具体动物猫的特有功能，可以将该对象进行向下转型。Cat c = (Cat)a;// 向下转型的目的就是为了使用子类中的特有数据。c.eat();c.catchMouse();// 反例，注意：对于转型，自始自终都是子类对象在做着类型的变化。// Animal a1 = new Dog();// Cat c1 = (Cat)a1; //ClassCastException异常 }public static void eatMethod(Animal a){a.eat();}
}

instanceof-类型判断

public static void eatMethod(Animal a)
{a.eat();// instanceof：用于判断对象的具体类型，只能用于引用数据类型判断// 通常在向下转型前用于健壮性的判断if(a instanceof Cat){Cat c = (Cat)a;c.catchMouse();}else if(a instanceof Dog){Dog d = (Dog)a;d.seehome();}
}

多态成员的特点

1、成员变量：

• 编译时，参考引用型变量所属的类中的是否有调用成员变量，若有，则编译通过，否则，编译失败。
• 运行时，参考引用型变量所属的类中的是否有调用成员变量，并运行该所属类中的成员变量。
• 简单而言，编译和运行都参考等于号的左边，that's all.

class Fu
{int num = 3;
}class Zi extends Fu
{int num = 4;
}class DuoTaiDemo2 
{public static void main(String[] args) {// 参考左边的 Zi zZi z = new Zi();System.out.println(z.num); // 4// 参考左边的 Fu fFu f = new Zi();System.out.println(f.num); // 3}
}

2、成员函数

• 编译时，参考引用型变量所属的类中的是否有调用的成员函数，若有，则编译通过，否则，编译失败。
• 运行时，参考的是对象所属的类中的是否有调用的函数。
• 简单而言，编译看左边，运行看右边。

class Fu
{void show(){System.out.println("fu show");}
}class Zi extends Fu
{void show(){System.out.println("zi show");}
}class DuoTaiDemo2 
{public static void main(String[] args) {Fu f = new Zi();f.show(); // zi show}
}

3、静态函数

• 编译时，参考引用型变量所属的类中的是否有调用的静态函数。
• 运行时，参考引用型变量所属的类中的是否有调用的静态函数。
• 简单而言，编译和运行都看左边。
• 其实对于静态方法，是不需要对象的，直接用类名调用即可。
  

内部类

内部类访问的特点

1. 内部类可以直接访问外部类中的成员。
2. 外部类要访问内部类的数据，必须要建立内部类的对象。

内部类的用法

一般用于类的设计，分析事物时，发现该事物描述中还有其他事物，而且这个事物还要访问被描述事物的内容，这时就是还有的事物定义成内部类来描述。

class Outer
{private int num1 = 3;class Inner1{void show(){System.out.println("show run..."+num1);}}private static int num2 = 33;static class Inner2{void show(){System.out.println("show run..."+num2);}}private static int num3 = 333;static class Inner3{void show(){System.out.println("show run..."+num3);}// 如果内部类中定义了静态成员，那么内部类也必须是静态的。static void func(){System.out.println("func run..."+num3);}}public void method(){Inner1 in = new Inner1();in.show();}
}class InnerClassDemo 
{public static void main(String[] args) {// 在外部类中的方法中实例化内部类对象来访问内部类内容Outer out = new Outer();out.method();// 直接访问外部类中的内部类中的内容Outer.Inner1 in1 = new Outer().new Inner1();in1.show();// 如果内部类是静态的，相当于一个外部类Outer.Inner2 in2 = new Outer.Inner2();in2.show();// 如果内部类是静态的，而且内部类的承成员也是静态的Outer.Inner3.func();}
}

小细节

为什么内部类能直接访问外部类中成员呢？

那是因为内部类持有了对外部类的应用。外部类名.this。

局部内部类

内部类可以存放在局部位置上。

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

class Outer
{int num = 3;void method(final int Y){final int X = 9;class Inner{void show(){System.out.println("show..." + X + "-" + Y);}}new Inner().show();}
}class InnerClassDemo2 
{public static void main(String[] args) {new Outer().method(8);}
}

匿名内部类

就是内部类的简写格式。

必须有前提：内部类必须继承或者实现一个外部类或者接口。

简单而言：匿名内部类其实就是一个匿名子类对象。

格式：new 父类or接口(){子类内容}

abstract class Demo
{abstract void show();
}class Ouetr
{int num = 8;void method(){// 匿名内部类new Demo(){void show(){System.out.println("show...." + num);}}.show();}
}

interface Inter
{void show1();void show2();
}class Outer
{int num = 6;void method(){Inter in = new Inter(){void show1(){System.out.println("show1..." + num);}void show2(){System.out.println("show2..." + num);}}in.show1();in.show2();}
}

内部类通常使用场景

1、当函数参数是接口类型时，而且接口中的方法不超过三个。可以用匿名内部类作为实际参数进行传递。

class InnerClassDemo2 
{public static void main(String[] args) {// new Outer().method(8);show(new Inter(){void show1(){//...}void show2(){//...}});}public static void show(Inter in){in.show1();in.show2();}
}

异常

定义

是在运行时期发生的不正常情况。

在Java中用类的形式对不正常情况进行了描述和封装对象。

描述不正常情况的类，就称为异常类。

以前正常流程代码和问题处理代码相结合，现在有了异常类之后，将正常流程代码和问题处理代码分离，提高阅读性。

其实异常类就是Java通过面向对象的思想将问题封装成了对象。用异常类对其进行描述。

不同的问题用不同的类进行具体的描述，比如角标越界，空指针异常等等等。

Demo

class ExceptionDemo
{public static void main(String[] args) {sleep(-5);sleep(1000000);}public static void sleep(int time){if(time < 0){抛出 new FuTime();}if(time > 100000){抛出 new BigTime();}System.out.println("睡觉...." + time + "分钟");}
}class Funtime extends Exception
{处理
}class BigTime extends Exception
{处理
}

体系

问题很多，意味着描述的类很多，将其共性进行向上抽取，形成了异常体系。

最终问题（不正常情况）就分成两大类。

Throwable：无论是error，还是Exception都是问题，问题发生就应可以抛出，让调用者知道并处理。

                       该体系的特点就在于Throwable及其所有的子类都具有可抛性。

                       可抛性到底指的是什么呢？怎么体现可抛性呢？

                       其实是通过两个关键字来体现的。

                       throws，throw，凡是可以被这两个关键字所操作的类和对象都具有可抛性。

1、一般不可以处理的——Error。

      特点：是有JVM抛出的严重性的问题。

                  这种问题发生一般不针对性处理，直接修改程序。

2、可以处理的——Exception。

该体系的特点：

子类的后缀名都是用其父类名作为后缀名的，阅读性很强。

自定义异常

先看看一个例子

class FuShuIndexException extends Exception
{FuShuIndexException(){}FuShuIndexException(String msg){super(msg);// 通过父类可以将msg显示在控制台上}
}class Demo
{public void method(int[] arr, int x) throws FuShuIndexException // 在次声明异常{if(x < 0)throw new FuShuIndexException("角标可不能为负数喔！");System.out.println(arr[x]);}
}class ExceptionDemo3 
{public static void main(String[] args) throws FuShuIndexException // 要在此进行声明次异常，如果FuShuIndexException继承RuntimeException，则次声明不需要{int[] arr = new int[3];Demo d = new Demo();d.method(arr, -5);}
}

对于角标是整数不存在，可以用角标越界来表示；对于角标为负数的情况，准备用负数角标异常来表示。

负数角标这种异常在Java中并没有定义过，那就按照Java异常的创建思想，面向对象，将负数角标进行自定义描述，并封装成对象。

这种自定义的问题描述称为自定义异常。

注意：如果让一个类称为异常类，必须要继承异常体系，因为只有称为异常体系的子类才有资格具有可抛性。才可以被两个关键字所操作，throws throw .

异常的分类

1、编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系。

      这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。这样的问题都可以针对性的处理。

2、编译时不检测异常（运行时异常）：就是Exception中的RuntimeException和其子类。

      这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的而或者引发了内部状态的改变导致的。

      那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行修改。

所以自定义异常时，要么继承Exception，要么继承RuntimeException。

throw和throws的区别

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

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

异常捕捉

异常处理的捕捉形式：

这是可以对异常进行针对性处理的方式。

具体格式：

try

{

   // 需要被检测异常的代码

}

catch(异常类 变量)  // 该变量用于接收发生的异常对象

{

   // 处理异常的代码

}

finally // 此处可以根据需求选择要不要

{

   // 一定会执行的代码

}

Demo：

class ExceptionDemo4 
{public static void main(String[] args) {int[] arr = new int[3];Test t = new Test();try{int num = t.method(arr, -5);System.out.println("num = "+num);}catch (FuShuIndexException e){System.out.println(e.getMessage());e.printStackTrace(); // jvm默认的异常处理机制就是调用异常对象的这个方法。}System.out.println("over");}
}class Test
{public int method(int[] arr, int x) throws FuShuIndexException{if(x < 0)throw new FuShuIndexException("角标出现负数啦！");return arr[x];}
}class FuShuIndexException extends Exception
{FuShuIndexException(){}FuShuIndexException(String msg){super(msg);}
}

多catch情况

如果有多个catch，且还有父类的catch，那么父类的catch放在最后，否则编译失败。

class ExceptionDemo4 
{public static void main(String[] args) {int[] arr = new int[3];Test t = new Test();try{int num = t.method(arr, -5);System.out.println("num = "+num);}catch (FuShuIndexException e){System.out.println(e.getMessage());e.printStackTrace(); // jvm默认的异常处理机制就是调用异常对象的这个方法。}catch(NullPointerException e){System.out.println(e.getMessage());}System.out.println("over");}
}class Test
{public int method(int[] arr, int x) throws FuShuIndexException, NullPointerException{if(arr == null)throw new NullPointerException("没有任何数组实体！");if(x < 0)throw new FuShuIndexException("角标出现负数啦！");return arr[x];}
}class FuShuIndexException extends Exception
{FuShuIndexException(){}FuShuIndexException(String msg){super(msg);}
}

异常处理的原则：

1、函数内容如果抛出需要检测的异常，那么函数上必须要声明。否则必须在函数内用trycatch捕捉，否则编译失败。

2、如果调用到了声明异常的函数，要么trycatch要么throws，否则编译失败。

3、什么时候catch，什么时候throws呢？

      功能内容可以解决，用catch。如果解决不了，用throws告诉调用者，由调用者解决。

4、一个功能如果抛出了多个异常，要么调用时，必须有对应多个catch进行针对性的处理。

      内部又几个需要检测的异常，就抛出几个异常，抛出几个，就catch几个。

finally代码块

例子：

finally代码块是很有用的。讲讲老毕说的例子：

连接数据库

查询

关闭连接

因为每一台设备被连接的数目是有限的，不能一直占用着资源，因为别人也要用到。那么服务器会判断一定的时间内没有跟数据库有信息交互的话，会自动关闭连接，如果在查询的时候出现了异常，那么也需要将连接关闭，释放资源。

try catch finally 代码块组合的特点：

1、第一种用法有 ：try catch finally

2、try catch（多个） 当没有必要的资源要释放的时候，可以不用定义finally。

3、try finally 如果异常无法直接用catch解决不了，那么就不要catch了，但是要抛出去给调用者进行异常处理。

包（package）

特点

1、对类文件进行分类管理

2、给类提供多层命名空间

3、写在程序文件的第一行

4、类名的全称的是 包名.类名

5、包也是一种封装形式

Demo:

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

编译的时候，产生一个mypack的文件夹，里边有PackageDemo.class文件，在doc控制台上编译：javac -d . PackageDemo.java

包-包之间的访问-protected

包与包之间的类进行访问，被访问的包中的类必须要public的，被访问的包中的类的方法也必须要public权限。

                  public                     protected                      default                             private

同一类中     ok                              ok                                 ok                                     ok   

同一包中     ok                              ok                                 ok

子  类  中     ok                              ok

不同包中     ok

导入import

Package mypack;import packa.DemoA; // 导入了packa包中的DemoA类。
//import packa.*; // 导入了packa包中的所有的类。开发过程中，不建议使用此方法。class PackageDemo 
{public static void main(String[] args) {System.out.println("Hello Package!");}
}

导包的原则：用到哪里个类，就导入哪个类。