一、继承（extends）
1.super关键字
super→父类对象
- 通过super关键字来实现对父类成员的访问，来引用当前对象的类
- super调用构造方法时只能是第一句
- super不能访问父类的private
2.继承
- 作用：
子类拥有父类的属性和方法，减少重复的代码，维护性高（代码简洁、提高了代码的复用性）
- 缺点：
提高了类之间的耦合性，会造成代码之间的联系越紧密，代码独立性越差
3.extends 与 implements 的区别
extends → 继承父类
interface → 定义接口
implements → 实现接口
相同点：都属于Java中的继承，都发生在多个类中
不同点：
extends只能是单继承，implements是多继承
extends继承父类时，父类中可以存在方法的默认实现
implements在实现接口时接口中不能有方法实现
extends发生在子类和父类之间，implements发生在实现类和接口之间
二、抽象类 （abstra）
- 抽象类特性：有构造方法，但是不可以创建对象
- 抽象类不能实例化对象，所以抽象类必须被继承才能被使用
- 一个类只能继承一个抽象类，一个类却可以实现多个接口
- 抽象子类可以继承抽象父类
- 抽象方法无方法体，不能创建对象
- abstra一般不与private、final、static共存
- 抽象类有构造函数，抽象类的构造函数由子类的super语句来调用，用于给抽象类中的成员初始化
- Java抽象类中可以包含main方法，它是一个静态方法
//抽象类
public abstract class Pet{
// 抽象方法
public abstract void toHospital();
}
抽象方法与抽象类的使用
- A 抽象类中可以没有抽象方法,但包含了抽象方法的类就必须被定义为抽象类
- B 没有抽象构造方法，也没有抽象静态方法
- C 抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
- 如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
public abstract class Base {
// A
public abstract void method1();
public abstract void method2();
public void method3(){}
// B
//public abstract Base(){}
//static abstract void method4();
// C
public Base(){
System.out.println("父类的无参构造方法");
}
// B
static void method4(){
System.out.print("静态方法表示类所特有的功能，这种功 能的实现不依赖于类的具体实例，也不依赖于它的子类。因此，当前类必须为静态方法提供实现");
}
}
三、重写（override）
外壳不变，核心重写
方法名、参数列表、返回值必须一致
class ElectricAppliance{
public void move(){
System.out.println("电器需要电压");
}
}
class Television extends Animal{
public void move(){
System.out.println("电视需要220伏");
}
}
public class TestTelevision {
public static void main(String args[]){
// ElectricAppliance对象
ElectricAppliance a = new ElectricAppliance();
// Television 对象
ElectricApplianceb = new Television ();
a.move();// 执行 ElectricAppliance类的方法
b.move();//执行 Television 类的方法
}
}
四、接口(interface)
1.接口 (无构造方法)→提高代码的可拓展性、后期的维护性
- 接口不是类，是抽象方法的集合
- 接口无法被实例化，但是可以被实现
- 接口包含类要实现的方法
- 接口必须以 I 开头命名
2.接口特性
- 接口里的所有方法必须是抽象方法
- 接口中只能声明静态常量
- 接口是被类实现的，而且可以多实现
- 接口中的方法都不能被static修饰
- 一个类只能继承一个抽象类，一个类却可以实现多个接口
3.接口的继承
- 一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法
- Hockey接口自己声明了四个方法，从Sports接口继承了两个方法，这样，实现Hockey接口的类需要实现六个方法
- 相似的，实现Football接口的类需要实现五个方法，其中两个来自于Sports接口
// 文件名: Sports.java
public interface Sports{
public void setHomeTeam(String name);
public void setVisitingTeam(String name);
}
// 文件名: Football.java
public interface Football extends Sports{
public void homeTeamScored(int points);
public void visitingTeamScored(int points);
public void endOfQuarter(int quarter);
}
// 文件名: Hockey.java
public interface Hockey extends Sports{
public void homeGoalScored();
public void visitingGoalScored();
public void endOfPeriod(int period);
public void overtimePeriod(int ot);
}五、多态
1.概念
- 多态是同一个行为具有多个不同表现形式或形态的能力
- 多态就是同一个接口，使用不同的实例而执行不同操作
- 多态也就是同一个事件发生在不同的对象上产生不同的结果
2.多态的三个必要条件
继承、重写、父类引用指向子类对象
abstract class ElectricAppliance{
abstract void form();
}
class Television extends ElectricAppliance{
public void form() {
System.out.println("扁平的长方体");
}
public void work() {
System.out.println("播放电视节目");
}
}
class Refrigerator extends ElectricAppliance{
public void form() {
System.out.println("高高的长方体");
}
public void work() {
System.out.println("存放食物");
}
}
public class Test {
public static void main(String[] args) {
show(new Refrigerator ()); // 以 Refrigerator 对象调用 show 方法
show(new Television ()); // 以 Television 对象调用 show 方法
Animal a = new Television (); // 向上转型
a.form(); // 调用的是 Television 的 form
Television c = (Television )a; // 向下转型
c.work(); // 调用的是 Television 的 work
}
public static void show(Animal a) {
a.form();
// 类型判断
if (a instanceof Refrigerator ) { // 冰箱做的事情
Refrigerator c = (Refrigerator )a;
c.work();
} else if (a instanceof Television ) { // 电视做的事情
Television c = (Television )a;
c.work();
}
}
}3.优点
- 多态可以消除耦合度
- 可替换性
- 可扩张性
- 接口性
- 灵活性
- 简化性
六、转型
1.向上转型（隐式/自动类型转型）
是小类型到大类型的转换
父类引用指向子类对象，自动进行类型补全
父类型 引用变量名 = new 子类型（）；
/测试方法
ElectricAppliance ea = new Television();
ea.setLifetime(20);
Master master = new Master();
master.maintain(ea );
2.向下转型（强制类型转换）
将一个指向子类对象的父类引用赋给一个子类的引用
父类类型转换为子类类型，需要强制类型转换，是大类型到小类型的转换（存在风险、溢出）
子类型 引用变量名 = （ 子类型 ） 父类型的引用变量
// 如果需要调用子类特有的方法
// 将pet 转换为Dog类型
Television tv=(Television )ElectricAppliance;
tv. selectTheChannel();// 执行tv特有的方法
3.instanceof → 用来对类型进行判断
public static void show(ElectricAppliance ea) {
ea.form();
// 类型判断
if (ea instanceof Television ) { // 电视做的事情
Television tv = (Television )ea;
tv.work();
} else if (ea instanceof Refrigerator ) {// 冰箱做的事情
Refrigerator rg = (Refrigerator )ea;
rg.work();
}
}
七、异常（阻止当前方法或作用域继续执行的问题）
1.三大类异常
用户操作失误、程序错误、物理错误
2.三种类型的异常
检查性异常、运行时异常、错误
3.Exception → 异常类
所有的异常类都是从java.lang.Exception类继承的子类
4.常见的异常
ArraylndexOutOfBoundaException → 数组下标越界
NullPointerException → 空指针异常
ClassNotFoundException → 找不到要加载的类
ClassCastException → 对象强制类型转换出错
5.捕获异常
try{
//程序代码（可能出现异常的代码）
}catch （捕获异常类型声明）{
e.printStack Trace ( ) ; →打印堆栈信息
}finally{
这里的代码永远都会执行
}
下边的例子中声明有两个元素的一个数组，当代码试图访问数组的第三个元素的时候就会抛出一个异常。
// 文件名 : ExcepTest.java
import java.io.*;
public class ExcepTest{
public static void main(String args[]){
try{
int a[] = new int[2];
System.out.println("数组中第3个元素为 :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
}
以上代码编译运行输出结果如下： Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 Out of the block
6.抛出异常
关键字throws/throw区别
throws throw
生成并抛出异常 声明方法内抛出了异常
位移方法体内部，可作为单独语句使用 必须跟在方法参数列表后面，不能单独使用
抛出一个异常对象，且只能是一个 声明抛出异常类型，可以跟多个异常
异常的原则
异常处理与性能
异常只能用于非正常情况
不要将过于庞大的代码块放在try中
在catch中指定具体的异常类型
需要对捕获的异常做处理
八、总结
1.instanceof的作用是什么？
判断一个引用类型变量所指向的对象是否是一个类(或接口、抽象类、父类)的实例，即它左边的对象是否是它右边的类的实例，该运算符返回boolean类型的数据
2.多态有何作用？
将不同的子类对象统一看做父类，屏蔽了不同子类之间的差异，有子类到父类，有特殊到一般，是程序变得通用。
3.如何实现多态？
利用继承，让派生类来重写父类的方法
抽象类的抽象方法实现多态
接口实现多态
4.异常分为Checked异常和运行时异常
5.Checked异常必须捕获或者声明抛出
6.运行时异常不要求必须捕获或者声明抛出
7.try-catch-finally中存在return语句的执行顺序
1.先执行try块中语句，出现异常，catch捕获到异常；
2，执行catch块中语句（包括return语句中的表达式运算），但不返回
3，再执行finally块，
4，执行finally块，有return，从这里返回。
8.finally块中语句不执行的情况
不进入try块、程序中止、线程中止
9.throw和throws关键字的区别
throws关键字在方法的声明上使用,表示此方法在调用的时候必须处理异常
throw关键字指的是在方法中，人为的抛出一个异常（这个异常对象可能是自己实例化，或者是抛出已经存在的）
381
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
