读书笔记--第4章：面向对象（下）

1：继承：在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。
　　在类的继承中，需要注意一些问题，具体如下：
（1）：在Java中，类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类。
（2）：多个类可以继承一个父类。
（3）：在Java中，多层继承是可以的。即一个类的父类可以再去继承另外的父类。
（4）：在Java中，子类和父类是一种相对的概念，也就是说一个类时某个类父类的同时，也可以是另一个类的子类。

2：子类可以对父类的方法进行重写。需要注意的是，在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。
注：子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限。子类中重写方法的访问权限只能和父类中的相同或者更加宽泛。

3：super关键字
Java提供了一个super关键字用于访问父类的成员。
（1）：使用super关键字访问父类的成员变量和成员方法。
（2）：使用super关键字访问父类的构造方法。
注：通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。

   构造方法调用顺序：
   先看子类构造第一行是否有super(...)，
   有的话就执行基类对应参数的构造函数，
   没有的话，执行基类无参构造函数。

https://editor.csdn.net/md/?articleId=107431444

4：final关键字
final修饰的类不能被继承。
final修饰的方法不能被子类重写。
final修饰的变量（成员变量和局部变量）是常量，只能赋值一次。
　　注：使用final关键字修饰成员变量时，虚拟机不会对其进行初始化。因此使用final修饰成员变量时，需要在定义变量同时赋予一个初始值。
　　
5：抽象类和接口
（1）抽象类：Java允许在定义方法时不写方法体。不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰。　　当一个类中包含了抽象方法，该类必须使用abstract关键字来修饰，使用abstract关键字修饰的类为抽象类。

在定义抽象类时需要注意，包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需使用abstract关键字来修饰即可。另外，抽象类时不可以被实例化，因为抽象类中可能包含抽象方法，抽象方法是没有方法体的，不可以被调用。

（2）接口：如果一个抽象类中的所以方法都是抽象的，则可以将这个类用另一种方式来定义，即接口。接口是由常量和抽象方法组成的特殊类，是对抽象类的进一步抽象。
语法格式如下：

[public] interface 接口名 [extends 接口1,接口2...]{
	[public] [static] [final] 数据类型 常量名 = 常量值 ; 
	[public] [abstract] 返回值 抽象方法名（参数列表）;
}

Java使用接口的目的是为了克服单继承的限制，因为一个类只能有一个父类，而一个类可以实现多个接口。接口中的变量默认使用“public static final”来修饰，即全局变量；接口中定义的方法默认使用“public abstract”来修饰，即抽象方法。如果接口声明为public，则接口中的变量和方法全部为public。
　　由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法。此时需要定义一个类，并使用implements关键字实现所有接口中的方法。
接口的特点：

• 接口中的方法都是抽象的，不能实例化对象
• 接口中的属性只能是常量
• 当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法
• 一个类通过implements关键字实现接口时，可以实现多个接口，被实现的多个接口之间要用逗号隔开
• 一个接口可以通过extends关键字继承多个接口，接口之间用逗号隔开
• 一个类在继承另一个类的同时还可以实现接口，此时，extends关键字必须位于implements关键字之前。（先继承，再实现）

6：多态
在同一个方法中，这种由于参数类型不同而导致执行效果各异的现象就是多态。继承是多态得以实现的基础。
将子类对象当作父类类型使用的情况，称为“向上转型”；使用时不需要任何显式地说明，需要注意的是，此时不能通过父类变量去调用子类特有的方法。（必要时，再将父类强制转换成子类）。
将父类类型当作子类型使用的情况，称为“向下转型”。注意类型不要出现错误。

Java提供一个关键字instanceof，它可以判断一个对象是否为某个类（或接口）的实例或者子类实例。

对象（或者对象引用变量） instanceof 类（或接口）

7：Object类：在JDK中提供了一个Object类，它是类层次结构的根类，每个类都直接或间接继承自该类，所有对象（包括数组）都实现了这个类的方法。
表：Object类中的常用方法

方法名称	方法说明
equals（）	指示其他某个对象是否与此对象“相等”
getClass（）	返回此Object运行时类
hashCode（）	返回该对象的哈希码值
toString（）	返回该对象的字符串表示

8：匿名内部类：在编写Java程序时，在类里面定义的类称之为内部类，内部类是外部类的一个成员。Java内部类可以分为成员内部类、方法内部类和匿名内部类等。

9：异常：Java语言中，引入了异常，以异常类的形式对这些非正常情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理。
异常类都继承java.long.Throwable类。
Error代表程序中产生的错误，Exception代表程序中产生的异常。

• Error类成为错误类，它表示Java运行时产生的系统内部错误或资源耗尽的错误，是比较严重的，仅靠修改程序本身是不能回复执行的。
• Exception类称为异常类，它表示程序本身可以处理的错误。在开发Java程序中进行的异常处理都是针对Exception类及其子类。在Exception类的众多子类中有一个特殊的RuntimeException类，该类及其子类用于表示运行时异常。除了此类，Exception类下所有其他的子类都用于表示编译类异常。
  表：Throwable常用方法

方法声明	功能描述
String getMessage()	返回此throwable的详细消息字符串
void printStackTrace()	将此throwable及其追踪输出至标准错误流
void printStackTrace(PointStream s)	将此throwable及其追踪输出至指定的错误流

10：try…catch和finally
　　try代码块中编写可能发生异常的Java语句，catch代码块中编写针对异常进行处理的代码。当try代码块中的程序发生了异常，系统会将这个异常的信息封装成一个异常对象，并将这个对象传递给catch代码块。catch代码块需要一个参数指明它所能够接受的异常类型，这个参数的类型必须是Exception类或其子类。
　　catch代码块对异常处理完毕后，程序仍会向下执行，而不会异常终止。
　　需要注意的是，在try代码块中，发生异常语句后面的代码是不会被执行的。

需要注意的是，finally中的代码块在一种情况下是不会执行的，
那就是在try...catch中执行了System.exit(0)语句。
System.exit(0)表示退出当前的Java虚拟机，Java虚拟机停止了，
任何代码都不能再执行了。

11：throws：使用throws关键字对外声明该方法有可能发生的异常。
　　（１）调用者需对异常进行处理，否则编译无法通过。
　　（２）不知道如何处理的话，也可以使用throws关键字继续将异常抛出，这样程序也能编译通过。但需要注意的是，程序一旦发生异常，如果没有被处理，程序就会非正常终止。

public class Ex {
	public static void main(String[] args) throws Exception{	//继续抛出
		int result = divide(4,0);		//程序异常终止
		System.out.println(result);
	}
	public static int divide(int x, int y) throws Exception{
		int result = x/y;
		return result;
	}
}

12：编译时异常和运行时异常
（1）：编译时异常（checked）：在Java中，Exception类中除了RuntimeException类及其子类外都是编译时异常。编译时异常的特点是Java编辑器会对其进行检查，如果出现异常就必须对异常进行处理，否则程序无法通过编译。
　　处理编译时期的异常有两种方式，具体如下。

• 使用try…catch语句对异常进行捕获。
• 使用throws关键字声明抛出异常，调用者对其处理。

（2）：运行时异常：RuntimeException类及其子类都是运行时异常。运行时异常的特点是Java编译器不会对其进行检查。也就是说，当程序中出现这类异常时，即使没有try…catch语句捕获或使用throws关键字声明抛出，程序也能编译通过。运行时异常一般是由程序中的逻辑错误引起的，在程序运行时无法恢复。例如通过数组的角标访问数组元素时，如果超过了数组的最大角标，就会发生运行时异常。

13：自定义异常
　　在Java中允许用户自定义异常，但自定义异常类必须继承自Exception或其子类。
　　如果没有特殊的要求，自定义的异常类只需继承Exception类，在构造方法中使用super（）语句调用Exception的构造方法即可。
　　throw关键字用于在方法中声明抛出异常的实例对象。 语法格式： throw Exception 异常对象。

public class Divide extends Exception{
	public Divide(){
		super();
	}
	public Divide(String message){
		super(message);
	}
}

public class Ex26 {
	public static void main(String[] args){
		try {
			int	result = divide(4,-2);
			System.out.println(result);
		} catch (Divide e) {
			System.out.println(e.getMessage());
		}
	}
	public static int divide(int x,int y) throws Divide{
		if(y<0){
			throw new Divide("除数是负数");
		}
		int result = x/y;
		return result;
	}
}

结果：

14：访问控制

• private（类访问级别）：如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其它成员访问，其它类无法直接访问。类的良好封装就是通过private关键字来实现的。
• default（包访问级别）：如果一个类或者类的成员不使用任何访问控制符修饰，则称它为默认访问控制级别，这个类或者类的成员只能被本包中的其它类访问。
• protected（子类访问级别）：如果一个类的成员被protected访问控制符来修饰，那么这个成员既能被同一个包下的其他类访问，也能被不同包下该类的子类访问。
• public（公共访问级别）：这是一个最宽松的访问控制级别，如果一个类或者类的成员被public访问控制符修饰，那么这个类或者类的成员能被所有的类访问，不管访问类与被访问类是否在同一个包。

表：访问控制级别

访问范围	private	default	protected	public
同一类中	可以	可以	可以	可以
同一包中		可以	可以	可以
子类中			可以	可以
全局范围				可以

思考题

1：请简述方法重写和方法重载的区别。
https://blog.csdn.net/geekmubai/article/details/81975990
转自其它博主
2：请列举抽象类和接口的区别。
（1）：从属性来看：

• 抽象类：属性定义和普通类没有区别
• 接口：属性必须是 public static final

（2）：从构造器来看：

• 抽象类：可以有自己的构造器
• 接口：没有构造器

（3）：从方法来看：

• 抽象类：可以有抽象方法和实例方法，也可以没有抽象方法
• 接口：只能有public 的抽象方法，可以有default方法和public static方法

（4）：从实现来看：

• 抽象类：子类继承抽象类，不要求实现抽象方法，当有抽象方法没有实现时，子类须声明为抽象类
• 接口：实现接口必须实现所有抽象方法

（5）：意义：

• 抽象类：对象是什么，实现了部分该类对象的通用方法，抽象方法部分则不同子类对象有不同的表现形式
• 接口：一系列行为或者服务的调用格式

——————————————————————————————————————————————
文章是新手所写，难免会有些知识点不全或者错误，还望发现错误的朋友，留言批评改正。