面向对象（下）
类的继承
类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类称为子类，现有类称为父类，子类会自动拥有父类所有可继承的属性和方法。（用extends关键字）
//定义Animal类
class Animal{
String name; //定义name属性
//定义动物叫的方法
void shout(){
System.out.println("动物发出叫声。");
}
}
//定义Dog类继承Animal类
class Dog extends Animal{
//定义一个打印name的方法
public void printName(){
System.out.println("name = "+name); //父类的name
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();//创建一个Dog类的实例对象
dog.name = "tony";//为Dog类的name属性赋值
dog.printName();//调用Dog类的printName（）方法
dog.shout();//调用Dog类继承来的shout（）方法
}
}
运行结果
name = tony
动物发出叫声。
注：①只支持单继承，不允许多重继承。②多个类可以继承一个父类。③多层继承是可以的，如A继承B，B继承C。
重写父类方法
在子类重写的方法要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。
//定义Animal类
class Animal{
//定义动物叫的方法
void shout(){
System.out.println("动物发出叫声。");
}
}
//定义Dog类继承Animal类
class Dog extends Animal{
//这里重写父类，定义狗叫的方法
void shout(){
System.out.println("汪汪...");
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();//创建一个Dog类的实例对象
dog.shout();//调用Dog类继承来的shout（）方法
}
}
运行结果
汪汪...
注：子类重写父类方法时，不能使用比父类中重写的方法更严格的访问权限，如父类中的方法是public的，子类方法就不能是private。
super关键字
super关键字用于访问父类成员，例如访问父类的成员变量、成员方法和构造方法。
①使用super关键字调用父类的成员变量和成员方法。格式为：
super.成员变量
super.成员方法([参数1，参数2...])
例：
class Animal{
String name = "动物";
void shout(){
System.out.println("动物发出叫声");
}
}
class Dog extends Animal{
//重写成员变量name
String name = "犬类";
//重写父类shout（）方法
void shout(){
super.shout(); //访问父类的成员方法
}
//打印name的方法
void printName(){
System.out.println("name = "+super.name); //访问父类的成员变量
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.shout();
dog.printName();
}
}
运行结果
动物发出叫声
name = 动物
②使用super关键字调用父类的构造方法。格式为：
super([参数1,参数2...])
例：
class Animal{
//定义Animal类有参的构造方法
public Animal(String name){
System.out.println("我是一只"+name);
}
}
class Dog extends Animal{
public Dog(){
super("二哈"); //调用父类有参的构造方法
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
}
}
运行结果
我是一只二哈
注：通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。还有，在子类的构造方法中一定会调用父类的某个构造方法,可以通过super指定调用父类的某个构造方法，如果没有指定，实例化子类对象时，会自动调用父类无参的构造方法（这时如果父类中没有无参的构造方法，会报错）。
定义一个类时，如果没有特殊要求，尽量在一个类中定义一个无参的构造方法，避免被继承时出现错误。
class Animal{
//定义Animal类无参的构造方法
public Animal(){
System.out.println("我只是一只动物");
}
//定义Animal类有参的构造方法
public Animal(String name){
System.out.println("我是一只"+name);
}
}
class Dog extends Animal{
//定义Dog类无参的构造方法
public Dog(){
//方法中无代码
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
}
}
运行结果
我只是一只动物
final关键字
final关键字可用于修饰类、变量和方法，它有“这是无法改变的”或“最终”的含义。有以下特性：
①final修饰的类不能被继承
②final修饰的方法不能被子类重写
当在父类中定义某个方法时，如果不希望被子类重写，就可以使用final关键字修饰该方法。
③final修饰的变量（成员变量和局部变量）是常量，只能赋值一次。
注：使用final关键字修饰成员变量时，虚拟机不会对其进行初始化，因此使用final修饰成员变量时，需要在定义变量的同时赋予一个初始值。
抽象类
定义方法时不写方法体，该方法称为抽象方法，必须使用abstract关键字修饰。当类中包含了抽象方法，该类也必须使用abstract修饰，该类称为抽象类。
抽象类不可以被实例化，因为抽象类中的抽象方法没有方法体，不能被调用，如果想调用抽象类中的方法，需要创建子类，在子类中将抽象类中的抽象方法进行实现。
//定义抽象类Animal
abstract class Animal{
//定义抽象方法shout（）
abstract void shout();
}
//定义Dog类继承抽象类Animal
class Dog extends Animal{
//实现抽象方法shout()
void shout(){
System.out.println("汪汪...");
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.shout();
}
}
运行结果
汪汪...
接口
如果一个抽象类中所有的方法都是抽象的，则可以将这个类用另一种方式来定义，即接口。定义接口时，需要使用interface关键字来声明。
interface Animal{
int ID = 1; //定义全局常量
void breathe(); //定义抽象方法
}
//接口中的变量默认使用“public static final”来修饰，即全局常量
//接口中定义的方法默认使用“public abstract”来修饰，即抽象方法
不能通过实例化调用接口中的方法，需要定义一个类，并使用implements关键字实现接口中的所有方法。
下面是类与接口之间实现的关系
//定义Animal接口
interface Animal{
int ID = 1; //定义全局常量
void breathe(); //定义抽象方法breathe()
void run(); //定义抽象方法run()
}
//Dog类实现了Animal接口
class Dog implements Animal{
//实现breathe()方法
public void breathe(){
System.out.println("狗在呼吸");
}
//实现run()方法
public void run(){
System.out.println("狗在跑");
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.breathe();
dog.run();
}
}
运行结果
狗在呼吸
狗在跑
还可以定义一个接口使用extends关键字去继承另一个接口
//定义Animal接口
interface Animal{
int ID = 1; //定义全局常量
void breathe(); //定义抽象方法breathe()
void run(); //定义抽象方法run()
}
//定义了LandAnimal接口，并继承了Animal接口
interface LandAnimal extends Animal{
void liveOnload(); //定义C抽象方法liveOnload()
}
//Dog类实现了LandAnimal接口
class Dog implements LandAnimal{
//实现breathe()方法
public void breathe(){
System.out.println("狗在呼吸");
}
//实现run()方法
public void run(){
System.out.println("狗在跑");
}
//实现liveOnload()方法
public void liveOnload(){
System.out.println("狗生活在陆地上");
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.breathe();
dog.run();
dog.liveOnload();
}
}
运行结果
狗在呼吸
狗在跑
狗生活在陆地上
注：①接口中的方法都是抽象的，不能实例化对象。②当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法（“class A implements B{}”A中的方法必须全在B中写出来，如果是“abstract class A implements B{}”则不需要全写）。③一个类通过implements关键字实现接口时，可以实现多个接口用逗号连接（class A implements B,C{}）。④一个接口可以通过extends关键字继承多个接口用逗号连接（interface A extends B,C{}）。⑤一个类在继承另一个类的同时还可以实现接口，此时，extends关键字必须位于implements关键字之前（class A extends B implements C{} 先继承，再实现）。
多态
在同一个方法中，由于参数类型不同而导致执行效果各异的现象就是多态。
为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。
//定义接口Animal
interface Animal{
void shout();
}
//定义Cat类实现Animal接口
class Cat implements Animal{
//实现shout（）方法
public void shout(){
System.out.println("喵喵");
}
}
//定义Dog类实现Animal接口
class Dog implements Animal{
//实现shout（）方法
public void shout(){
System.out.println("汪汪");
}
}
public class Test {
//定义静态的animalShout（）方法，接收一个Animal类型的参数
public static void animalShout(Animal an){
an.shout(); //调用实际参数的shout（）方法
}
public static void main(String[] args) {
Animal an1 = new Cat(); //创建Cat对象，使用Animal类型的变量an1引用
Animal an2 = new Dog(); //创建Dog对象，使用Animal类型的变量an2引用
animalShout(an1); //调用animalShout（）方法，将an1作为参数传入
animalShout(an2); //调用animalShout（）方法，将an2作为参数传入
}
}
运行结果
喵喵
汪汪
所以多态不仅解决了方法同名的问题，而且还使程序变得更加灵活，从而有效地提高程序的可扩展性和可维护性。
对象的类型转换
多态中，涉及到将子类对象当作父类类型使用的情况，如上面代码所写到的这两行：
Animal an1 = new Cat(); //将Cat对象当作Animal类型来使用
Animal an2 = new Dog(); //将Dog对象当作Animal类型来使用
注：此时不能通过父类变量去调用子类中的某些方法（这里的某些方法指的是子类中有的方法而父类中没有）。
//定义接口Animal
interface Animal{
void shout();
}
//定义Cat类实现Animal接口
class Cat implements Animal{
//实现抽象shout（）方法
public void shout(){
System.out.println("喵喵");
}
//定义sleep（）方法
void sleep(){
System.out.println("猫睡觉");
}
}
public class Test {
//定义静态的animalShout（）方法，接收一个Animal类型的参数
public static void animalShout(Animal animal){
animal.shout(); //调用传入参数Animal的shout（）方法
//编译器检查到下面这行时，发现Animal类中没有定义sleep（）方法，会报错
animal.sleep(); //调用传入参数Animal的sleep（）方法
}
public static void main(String[] args) {
Cat cat = new Cat(); //创建Cat实例对象
animalShout(cat); //调用animalShout（）方法，将cat作为参数传入
}
}
以上代码会报错，所以需要进行强制类型转换，将animalShout（）方法改为：
public static void animalShout(Animal animal){
Cat cat = (Cat) animal; //将animal对象强制转换为Cat类型
cat.shout(); //调用传入参数Animal的shout（）方法
cat.sleep(); //调用传入参数Animal的sleep（）方法
}
修改后运行结果
喵喵
猫睡觉
需要注意的是，在类型转换时也可能出现错误，当animalShout（）方法传入Dog类型的对象时，会报错，例：
//定义接口Animal
interface Animal{
void shout();
}
//定义Cat类实现Animal接口
class Cat implements Animal{
//实现抽象shout（）
public void shout(){
System.out.println("喵喵");
}
//定义sleep（）方法
void sleep(){
System.out.println("猫睡觉");
}
}
//定义Dog类实现Animal接口
class Dog implements Animal{
public void shout(){
System.out.println("汪汪");
}
}
public class Test {
//定义静态的animalShout（）方法，接收一个Animal类型的参数
public static void animalShout(Animal animal){
Cat cat = (Cat) animal; //将animal对象强制转换为Cat类型
cat.shout(); //调用传入参数Animal的shout（）方法
cat.sleep(); //调用传入参数Animal的sleep（）方法
}
public static void main(String[] args) {
Dog dog = Dog(); //创建Cat实例对象
animalShnew out(dog); //调用animalShout（）方法，将cat作为参数传入
}
}
程序运行会出错，原因是在调用animalShout（）方法时，传入一个Dog对象，在强制类型转换时，Animal类型的变量无法强转为Cat类型。
针对这种情况，Java提供了关键字instanceof，它能判断一个对象是否为某个类（或接口）的实例或者子类实例，如b instanceof A ，b为子类对象或者实现类对象，
语法：
对象（或者对象引用变量） instanceof 类（或接口）
对animalShout（）方法进行修改后
public static void animalShout(Animal animal){
if(animal instanceof Cat){ //判断animal是否是Cat类的实例对象
Cat cat = (Cat) animal; //将animal对象强制转换为Cat类型
cat.shout(); //调用传入参数Animal的shout（）方法
cat.sleep(); //调用传入参数Animal的sleep（）方法
}
else
System.out.println("这个动物不是猫");
}
运行结果
这个动物不是猫
使用instanceof关键字判断animalShout（）方法中传入的对象是否为Cat类型，如果是就进行类型转换，否则输出“这个动物不是猫”。
Object类
Object类是所有类的父类。比如toString（）方法，在该方法中输出了对象的基本信息，但也可以在其它类中用对其重写。
class Animal{
//重写Object类的toString（）方法
public String toString(){
return "I am an Animal";
}
}
public class Test {
public static void main(String[] args) {
Animal an = new Animal();
System.out.println(an.toString());
}
}
运行结果
I am an Animal
如果不对其重写会输出“类名+16进制表示的该对象哈希值”，如“Animal@b4c966a”
匿名内部类
之前都是用子类来实现接口，并根据该类进行实例化。除此之外，还可以使用匿名内部类来实现接口。
匿名内部类格式：
new 父类（参数列表）或父接口(){//匿名内部类实现部分}
//定义动物类接口
interface Animal{
void shout();
}
public class Test {
//定义静态方法animalShout（）
public static void animalShout(Animal an){
an.shout();
}
public static void main(String[] args) {
//定义匿名内部类作为参数传递给animalShout（）方法
animalShout(new Animal(){
//实现shout（）方法
public void shout(){
System.out.println("喵喵");
}
});
}
}
运行结果
喵喵
接下来分两步来编写匿名内部类（以便容易理解）：
①在new Animal()后面又一对大括号，表示创建的对象是Animal的子类实例，该子类是匿名的。
animalShout(new Animal(){});
②在大括号中编写匿名子类的实现代码。
animalShout(new Animal(){
//实现shout（）方法
public void shout(){
System.out.println("喵喵");
}
});
异常
举一个ArithmeticExceotion异常：
public class Test {
public static void main(String[] args) {
int result = divide(4,0);
System.out.println("结果： "+result);
}
public static int divide(int x,int y){
int result = x/y;
return result;
}
}
运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.divide(Test.java:7)
at Test.main(Test.java:3)
Throwable类中包含两大类Error类和Exception类。
Error类称为错误类，表示Java运行时产生的系统内部错误或资源耗尽的错误，比较严重，仅靠修改程序本身是不能恢复执行的；
Exception类称为异常类，它表示程序本身可以处理的错误。
|
Throwable常用方法
|
|
|
方法声明
|
功能描述
|
|
String getMessage()
|
返回此throwable的详细消息字符串
|
|
void printStackTrace()
|
将此throwable及其追踪输出至标准错误流
|
|
void printStackTrace(PrintStream s)
|
将此throwable及其追踪输出到指定的输出流
|
try...catch和finally
由于发生异常，程序立即终止，无法继续执行下去，所以提供了异常的处理方式--异常捕获。异常捕获通常使用try...catch语句，格式：
try{
//程序代码块
}catch(ExceptionType(Exception类及其子类) e){
//对ExceptionType的处理
}
需要注意的是，在try代码块中，发生异常语句后面的代码不会被执行，如下面的“System.out.println(result);”没有执行。
public class Test {
public static void main(String[] args) {
//下面的代码定义了一个try...catch语句用于捕获异常
try{
int result = divide(4,0);
//发生异常，下面这条语句没被执行
System.out.println("结果： "+result);
}catch (Exception e){ //对异常进行处理
System.out.println("捕获的异常信息为："+e.getMessage());
}
}
public static int divide(int x,int y){
int result = x/y;
return result;
}
}
运行结果
捕获的异常信息为：/ by zero
还有finally代码块，无论是否发生异常后面代码都会被执行。由于这种特性，在程序设计时，经常会在try...catch后使用finally代码块来完成必须做的事情，例如释放系统资源。
public class Test {
public static void main(String[] args) {
//下面的代码定义了一个try...catch语句用于捕获异常
try{
int result = divide(4,0);
System.out.println("结果： "+result);
}catch (Exception e){ //对异常进行处理
System.out.println("捕获的异常信息为："+e.getMessage());
return; //用于结束当前语句
}finally{
System.out.println("进入finally代码块");
}
System.out.println("程序继续向下执行...");
}
public static int divide(int x,int y){
int result = x/y;
return result;
}
}
运行结果
捕获的异常信息为：/ by zero
进入finally代码块
return语句用于结束当前语句，所以“System.out.println("程序继续向下执行...");”就不会执行了，而finally中的代码仍然会执行。总的来说就是不会被return语句和异常影响。
注：当在try...catch中执行了System.exit(0)语句finally中的代码就不会执行了，System.exit(0)语句表示退出当前的Java虚拟机，任何代码都不会被执行了。还有一种是try代码块中没有代码运行finally也不会被运行。
throws关键字
在方法的后面使用throws关键字对外声明该方法有可能发生异常。格式：
修饰符 返回值类型 方法名（[参数1，参数2...]）throws ExceptionType1[,ExceptionType2...]{}
如果在某方法上声明抛出异常，就必须使用try...catch对该方法进行处理，否则会报错。
public class Test {
public static void main(String[] args) {
//下面的代码定义了一个try...catch语句用于捕获异常
try{
int result = divide(4,2);
System.out.println("结果： "+result);
}catch (Exception e){ //对异常进行处理
e.printStackTrace(); //打印捕获的异常信息
}
}
//下面的方法实现了两个数相除，并使用throws关键字声明抛出异常
public static int divide(int x,int y)throws Exception{
int result = x/y;
return result;
}
}
运行结果
结果： 2
使用throws关键字声明抛出异常后，即使不会出现被0除的现象，但如果不用try...catch编译程序依然会报错。
自定义异常
在程序开发时，有可能会用到一些自己描述的特殊的异常情况，Java中允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类。
自定义了异常，就需要用到throw关键字，throw关键字用于在方法中声明抛出异常的实例对象。格式：
throw Exception异常对象
下面是一个当被除数是负数时抛出自定义异常的例子。
//下面自定义一个异常类继承自Exception
class DivideByMinusExpetion extends Exception{
public DivideByMinusExpetion(){
super(); //调用Exception无参的构造方法
}
public DivideByMinusExpetion(String message){
super(message); //调用Exception有参的构造方法
}
}
public class Test {
public static void main(String[] args) {
//下面的代码定义了一个try...catch语句用于捕获异常
try{
int result = divide(4,-2);
System.out.println("结果： "+result);
}catch (DivideByMinusExpetion e){ //对异常进行处理
System.out.println("异常信息："+e.getMessage()); //打印捕获的异常信息
}
}
//下面的方法实现了两个数相除，并使用throws关键字声明抛出异常
public static int divide(int x,int y)throws DivideByMinusExpetion{
if(y<0){
//使用throw关键字声明异常对象
throw new DivideByMinusExpetion("被除数是负数");
}
int result = x/y;
return result;
}
}
运行结果
异常信息：被除数是负数
下面是直接用Exception类，输出结果同上
public class Test {
public static void main(String[] args) {
try{
System.out.println(divide(4,-2));
}catch (Exception e){
System.out.println("异常信息："+e.getMessage());
}
}
public static int divide(int x,int y)throws Exception{
if(y<0){
throw new Exception("被除数是负数");
}
return x/y;
}
}
包
Java中的包是专门用来存类的，通常功能相同的类存放在相同的包中。在声明包时，用package语句。
package cn.itcast;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
运行结果
Hello World!
import语句
使用import语句导包。
如果两个类不在同一目录下，引用某个类时需要用import导包，格式：
import 包名.类名;
例如：import cn.itcast.Student;然后在实例化对象的时候就可以直接用Student s = new Student(); ,但如果没有导包，实例化对象时需指明位置，就得写成cn.itcast.Student s = new cn.itcast.Student(); 。
访问控制
Java中，针对类、成员方法和属性提供了四种访问级别，访问控制级别由小到大：private,default,protected,public。
- private（类访问级别）：如果类成员被其修饰，该成员只能被该类的其他成员访问。
- default（包访问级别）：如果一个类或者类的成员不使用任何访问控制修饰符修饰，则称则称它为默认访问控制级别，这个类或者类的成员只能被本包中的其他类访问。
- protected（子类访问级别）：如果类成员被其修饰，该成员既能被同一包下的其他类访问，也能被不同包下的子类访问。
- public（公共访问级别）：如果一个类或者类成员被其修饰，不管访问类与被访问类在不在同一个包中，都能被访问。
注：private和protected不能修饰类，只能修饰类成员。