Java入门三

  • 类的继承
  • final关键字
  • 抽象类与接口
  • 抽象类
  • 接口
  • 多态
  • 内部类
  • 异常


类的继承

继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。
类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类。
子类继承父类的属性和方法，使得子类对象（实例）具有父类的特征和行为。
在程序中，如果想声明一个类继承另一个类，需要使用extends关键字，语法格式如下所示。

/*
	class 父类{
 		 ……
	}
	class 子类 extends 父类{
		  …… 
	}

*/

子类在继承父类的时候，会自动继承父类的成员。
除了继承父类的属性和方法，子类也可以定义自己的属性和方法。
继承中需要注意的问题。
（1）在Java中，类只支持单继承，不允许多重继承。也就是说一个类只能有一个直接父类。
（2）多个类可以继承一个父类。
（3）在Java中，多层继承也是可以的，即一个类的父类可以再继承另外的父类。
（4）在Java中，子类和父类是一种相对概念，一个类可以是某个类的父类，也可以是另一个类的子类。
在继承中，子类不能直接访问父类中的私有成员，子类可以调用父类的非私有方法，但是不能调用父类的私有成员。
在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。
在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型，且在子类重写的方法不能拥有比父类方法更加严格的访问权限。
子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限。
当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，Java提供了 super关键字，super关键字可以在子类中调用父类的普通属性、方法以及构造方法。
super关键字的具体用法
（1）使用super关键字访问父类的成员变量和成员方法

super.成员变量
super.成员方法(参数1,参数2…)

（2）使用super关键字访问父类中指定的构造方法

super(参数1,参数2…)

通过super()调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。


java 父类拥有子类的属性 java父类定义子类对象_java-ee

this和super两者不可以同时出现，因为this和super在调用构造方法时都要求必须放在构造方法的首行。

final关键字

在Java中，可以使用final关键字声明类、属性、方法，在声明时需要注意以下几点：
（1）使用final修饰的类不能有子类。
（2）使用final修饰的方法不能被子类重写。
（3）使用final修饰的变量（成员变量和局部变量）是常量，常量不可修改。
Java中的类被final关键字修饰后，该类将不可以被继承，也不能够派生子类。
当一个类的方法被final关键字修饰后，这个类的子类将不能重写该方法。
当在父类中定义某个方法时，如果不希望被子类重写，就可以使用final关键字修饰该方法。
Java中被final修饰的变量是为常量，常量只能在声明时被赋值一次，在后面的程序中，其值不能被改变。如果再次对该常量赋值，则程序会在编译时报错。
在使用final声明变量时，要求全部的字母大写。
如果一个程序中的变量使用public static final声明，则此变量将成为全局变量,例如：

public static final String NAME = "dog";

抽象类与接口

抽象类

抽象方法是使用abstract关键字修饰的成员方法，抽象方法在定义时不需要实现方法体。

abstract void 方法名称(参数);

当一个类包含了抽象方法，该类必须是抽象类。抽象类和抽象方法一样，必须使用abstract关键字进行修饰。
抽象类的定义：

abstract class 抽象类名称{
    访问权限 返回值类型 方法名称(参数){
           return [返回值];
    }
    访问权限 abstract 返回值类型 抽象方法名称(参数);     //抽象方法，无方法体
}

抽象类的定义规则如下：
（1）包含一个以上抽象方法的类必须是抽象类。
（2）抽象类和抽象方法都要使用abstract关键字声明。
（3）抽象方法只需声明而不需要实现。
（4）如果一个类继承了抽象类，那么该子类必须实现抽象类中的全部抽象方法。
使用abstract关键字修饰的抽象方法不能使用private修饰，因为抽象方法必须被子类实现，如果使用了private声明，则子类无法实现该方法。

接口

如果一个抽象类的所有方法都是抽象的，则可以将这个类定义接口。
接口是一种特殊的类，由全局常量和公共的抽象方法组成，不能包含普通方法。
接口中除了抽象方法外，还可以有默认方法和静态方法(也叫类方法)，默认方法使用default修饰，静态方法使用static修饰，且这两种方法都允许有方法体。
接口使用interface关键字声明。
其格式如下：

public interface 接口名 extends 接口1,接口2... {
	public static final 数据类型 常量名 = 常量值; 
	public default 返回值类型 抽象方法名(参数列表);
     public abstract 返回值类型 方法名(参数列表){
        //默认方法的方法体
     }
     public abstract 返回值类型方法名(参数列表){
        //类方法的方法体
     }
}

“extends 接口1,接口2…”表示一个接口可以有多个父接口，父接口之间使用逗号分隔。
接口中的变量默认使用“public static final”进行修饰，即全局常量。
接口中定义的方法默认使用“public abstract”进行修饰，即抽象方法。
如果接口声明为public，则接口中的变量和方法全部为public。
不管写不写访问权限，接口中的方法访问权限永远是public。
与抽象类一样，接口的使用必须通过子类，子类通过implements关键字实现接口，并且子类必须实现接口中的所有抽象方法。
一个类可以同时实现多个接口，多个接口之间需要使用英文逗号(,)分隔。
定义接口的实现类:

修饰符 class 类名 implements 接口1,接口2,...{
    ...
}

接口的实现类，必须实现接口中的所有方法
如果在开发中一个子类既要实现接口又要继承抽象类，则可以按照以下格式定义子类。

修饰符class 类名 extends 父类名implements 接口1,接口2,... {
    ...
}

在Java中，接口是不允许继承抽象类的，但是允许一个接口继承多个接口。

多态

多态是指不同对象在调用同一个方法时表现出的多种不同行为。
在同一个方法中，由于参数类型不同而导致执行效果不同的现象就是多态。
Java中多态主要有以下两种形式：
（1）方法的重载。
（2）对象的多态性（方法重写）。
对象类型转换主要分为以下两种情况：
（1）向上转型：子类对象→父类对象。
（2）向下转型：父类对象→子类对象。
对于向上转型，程序会自动完成，而向下转型时，必须指明要转型的子类类型。
对象类型的转换格式如下所示。

/*
对象向上转型：父类类型 父类对象 = 子类实例;


对象向下转型：
父类类型 父类对象 = 子类实例;
子类类型 子类对象 = （子类）父类对象;
*/

如果对象发生了向上转型关系后，所调用的方法一定是被子类重写过的方法。
在进行对象的向下转型前，必须发生对象向上转型，否则将出现对象转换异常。
在向下转型时，不能直接将父类实例强制转换为子类实例
Java中可以使用instanceof关键字判断一个对象是否是某个类（或接口）的实例，例如：

对象  instanceof类（或接口）

在上述格式中，如果对象是指定的类的实例对象，则返回true，否则返回false。

Java提供了一个Object类，它是所有类的父类，每个类都直接或间接继承Object类，因此Object类通常被称之为超类。

当定义一个类时，如果没有使用extends关键字为这个类显式地指定父类，那么该类会默认继承Object类。

java 父类拥有子类的属性 java父类定义子类对象_java_02

在实际开发中，通常希望对象的toString()方法返回的不仅仅是基本信息，而是对象特有的信息，这时可以重写Object类的toString()方法。

内部类

在Java中，允许在一个类的内部定义类，这样的类称作内部类，内部类所在的类称作外部类。
根据内部类的位置、修饰符和定义方式的不同，内部类可分为4种，分别是成员内部类、局部内部类、静态内部类、匿名内部类。

在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。成员内部类可以访问外部类的所有成员。
内部类可以在外部类中使用，并能访问外部类的成员。
如果想通过外部类访问内部类，则需要通过外部类创建内部类对象，创建内部类对象的具体语法格式如下：

//外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

局部内部类，也叫作方法内部类，是指定义在某个局部范围中的类，它和局部变量一样，都是在方法中定义的，有效范围只限于方法内部。
在局部内部类中，局部内部类可以访问外部类的所有成员变量和方法，而局部内部类中变量和方法却只能在所属方法中访问。
静态内部类，就是使用static关键字修饰的成员内部类。
在形式上，静态内部类只是在内部类前增加了static关键字，但在功能上，静态内部类只能访问外部类的静态成员，通过外部类访问静态内部类成员时，可以跳过外部类直接访问静态内部类。
创建静态内部类对象的基本语法格式如下：

//外部类名.静态内部类名 变量名 = new 外部类名().静态内部类名();

匿名内部类是没有名称的内部类。
创建匿名内部类的基本语法格式如下：

/*
	new 父接口(){
 	  //匿名内部类实现部分
	}
*/

在Java中调用某个方法时，如果该方法的参数是接口类型，除了可以传入一个接口实现类，还可以使用实现接口的匿名内部类作为参数，在匿名内部类中直接完成方法的实现。

异常

针对程序运行时磁盘空间不足、网络连接中断、被装载的类不存在等问题。Java语言引入了异常，以异常类的形式对这些非正常情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理。

Java提供了大量的异常类，这些类都继承自java.lang.Throwable类。

java 父类拥有子类的属性 java父类定义子类对象_子类_03

Throwable有两个直接子类Error和Exception。

Error代表程序中产生的错误，Exception代表程序中产生的异常。

Error类称为错误类，它表示Java程序运行时产生的系统内部错误或资源耗尽的错误，这类错误比较严重，仅靠修改程序本身是不能恢复执行的。

Exception类称为异常类，它表示程序本身可以处理的错误，在Java程序中进行的异常处理，都是针对Exception类及其子类的。

Exception类的众多子类中有一个特殊的子类—RuntimeException类，RuntimeException类及其子类用于表示运行时异常。

java 父类拥有子类的属性 java父类定义子类对象_java_04

出现异常后，程序会立即终止。为了解决异常，Java提供了对异常进行处理的方式一一异常捕获。

异常捕获使用try…catch语句实现，try…catch具体语法格式如下：

try{
    //程序代码块
}catch(ExceptionType(Exception类及其子类) e){
    //对ExceptionType的处理
}

当try代码块中的程序发生了异常，系统会将异常的信息封装成一个异常对象，并将这个对象传递给catch代码块进行处理。catch代码块需要一个参数指明它所能够接收的异常类型，这个参数的类型必须是Exception类或其子类。
在程序中，有时候会希望有些语句无论程序是否发生异常都要执行，这时就可以在try…catch语句后，加一个finally代码块。
在程序设计时，通常会使用finally代码块处理完成必须做的事情，如释放系统资源。
finally中的代码块在一种情况下是不会执行的，那就是在try…catch中执行了**System.exit(0)**语句。System.exit(0) 表示退出 当前的Java虚拟机，Java虚拟机停止了，任何代码都不能再执行了。
Java允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常。
throws关键字声明抛出异常的语法格式如下：

/*
	修饰符 返回值类型 方法名(参数1，参数2.....)throws 异常类1, 异常类2.....{
    	    //方法体.....
	}
*/

在程序编译时产生一些异常，这些异常必须要进行处理，这种异常被称为编译时异常，也称为checked异常。
在程序运行时产生的，这种异常即使不编写异常处理代码，依然可以通过编译，因此被称为运行时异常，也称为unchecked异常。
1．编译时异常
在Exception类中，除了RuntimeException类及其子类，Exception的其他子类都是编译时异常。
处理编译时期的异常有两种方式，具体如下：
（1）使用try…catch语句对异常进行捕获处理。
（2）使用throws关键字声明抛出异常，调用者对异常进行处理。
2．运行时异常
RuntimeException类及其子类都是运行时异常。
Java允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类。
如果没有特殊的要求，自定义的异常类只需继承Exception类，在构造方法中使用super()语句调用Exception的构造方法即可。
自定义异常类中使用throw关键字在方法中声明异常的实例对象，格式如下：

//  throw Exception异常对象

面向对象先写这么多，等后期写案例在具体介绍用法。