标签：Exception 异常 面向对象 子类 抽象类 父类 方法
一、类的继承
1、概念：在一个现有类的基础上去构建一个新的类，构建出来的新类称为子类，现有的类称为父类。子类继承父类的属性和方法，使得子类对象具有父类
的特征和行为。（用关键字 extends 表示继承关系）。
2、作用： 提高了代码的复用性。
让类与类之间产生了关系，有了这个关系，才有了多态的特性。 【注意】（1）在Java中，类只支持单继承，不允许多重继承。即，一个类只能有一个直接父类。 （2）多个类可以继承一个父类。 (3) 在Java中，多层继承也是可以的，即，一个类的父类可以再继承另外的父类。 （4）在Java中，子类和父类是一种相对的概念，一个类可以是某个类的父类，也可以是另一个类的子类。 二、方法的重写 1、概念：在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。在子类中重写的方法 需要和父类被重写的方法具有相同的方法名、参数列表和返回值类型，且在子类重写的方法不能拥有父类方法更加严格的访问权限。 2、【注意】（1）子类方法覆盖父类方法时，必须保证子类方法权限大于等于父类方法权限，才可以覆盖，否则编译失败。 public > protected > <default> > private （2）静态方法只能重写（覆盖）静态方法（static） （3）重载（overload）：只看同名方法的参数列表，在同一个类中。 重写（override）：子父类方法要一模一样（方法名、返回值、参数列表），在子父类中。 三、super关键字 1、概念：当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，而super关键字可以在子类中调用父类的普通属性、方法和构造方法。 2、具体用法：（1）使用super关键字访问父类的成员变量和成员方法。 super.成员变量 super.成员方法（参数1，参数2...） （2）使用super关键字访问父类中指定的构造方法 super(参数1，参数2...) 【注意】super()语句必须定义在子类构造方法的第一行，并且只能出现一次。 super 的用法和 this 的用法很相似：this 代表的是本类对象的引用。super 代表的是父类。 四、final关键字 final：最终的，用于修饰类、变量和方法 ➢ final 修饰的类，不可以被继承。 ➢ final 修饰的方法，不可以被重写。 ➢ final 修饰的变量（成员变量和局部变量），变为一个常量，只能赋值一次。 1、final关键字修饰类 Java中的类被final关键件字修饰后，该类将不可以被继承，即不能派生子类。 例如：
运行结果：不好好学习
会报错，不能在被子类在继承
2、final关键字修饰类 当一个类的方法被final关键字修饰后，这个类的子类将不能重写该方法。
（1）特点：
* 方法只有声明没有实现内容时，该方法可以定义成抽象方法，使用 abstract 表示，方法不需要写方法体{}，直接分号“;”结束就行。 抽象方法必须定义在抽象类中，该类也必须被 abstract 修饰。 *抽象类不可以被实例化。因为调用抽象方法没有意义（方法体没有被实现） *抽象类必须有子类覆盖了所有的抽象方法后，该子类才能实例化。否则，这个子类还是抽象类。 (2)【注意】抽象类中有构造方法，用于给子类对象进行初始化。 抽象类可以不定义抽象方法，但是很少见，目的就是为了不让该类创建对象。 抽象 abstract 关键字不可以和哪些关键字共存？ *private 不行（子类无法覆盖） *static 不行（类名调用没有内容） *final 不行（final 方法不能被重写） 抽象类和一般类的异同点: *相同点：抽象类和一般类都是用来描述事物的，都在内部定义了成员。 *不同点：a.一般类有足够的信息描述事物；抽象类描述事物的信息有可能不足。 b.一般类中不能定义抽象方法，只能定义非抽象方法；抽象类中可以定义抽象方法，也可以定义非抽象方法。 c.一般类可以被实例化;抽象类不可以被实例化。 抽象类一定是个父类,因为需要子类覆盖其方法后才可以对子类实例化。 2、接口 （1）概念:当一个抽象类中所有的方法都是抽象方法时，我们可以将该抽象类用另一种形式定义和表示，就是接口，使用关键字 interface 表示。 【注意】对于接口当中常见的成员：这些成员都有固定的修饰符：a.全局常量：public static final b.抽象方法：public abstract (2) 接口源文件也是.java 扩展名，在编译后也是生成的.class 文件。类与类之间是继承关系，类与接口之间是实现关系。接口不可以实例化。 只能由实现了接口的子类，并覆盖了接口中所有的抽象方法后，该子类才可以实例化。否则，这个子类就是一个抽象类。 (3)怎么使用接口呢？----实现，使用 implements 关键字 (4)一个类可以实现多个接口:
一个类在继承另一个类的同时，还可以实现多个接口:
(5)接口和接口之间还可以继承，而且接口可以多继承。但是，这个继承体系中的方法都要在子类中覆盖实现。
【注意】子类在实现接口的方法时，要把方法修饰成 public 的，因为接口在定义时，方法默认是 public，即使没有显式的写出来。
（6）接口和抽象类异同点：
*相同点：都是不断向上抽取而来的。
*不同点：a.抽象类需要被继承 extends，而且只能单继承；接口需要被实现 implements，而且可以多实现。
b.抽象类中可以定义抽象方法，也可以定义非抽象方法，子类在继承抽象类后，可以直接使用其中的非抽象方法；接口中只能定义抽象方法，必须由子类去实现。
c.抽象类的继承，是 is a 关系，他是在定义该体系中的基本共性内容；接口的实现，是 like a 关系，他是在定义体系的额外功能。
六、多态
1、概念：在同一个方法中，由于参数类型不同而导致执行效果各异的现象就是多态。继承是多态得以实现的基础。
2、体现：父类或者接口的引用（引用型变量）指向自己的子类对象。
3、前提：必须是类与类之间有关系，要么继承 extends，要么实现 implements。
4、好处：多态的出现大大提高了程序的扩展性，前期定义的代码可以使用后期的内容。
弊端：只能使用父类的引用访问父类中的成员，前期定义的内容不能使用后期子类的特有内容。 5、多态的转型 （1）向上转型：
【注意】这样就无法调用猫中定义的专属功能了。（子类特有的功能就无法使用了）
向上转型：自动类型提升，子类对象转成父类类型。
猫对象提升成了动物类型，但是特有功能无法访问，子类特有方法被隐藏了。
（2）向下转型：
【注意】里面的小括号是强制性转换，外面的小括号是让它先执行。
如果想调用 Cat 类的特有方法，我们就必须强制将父类的引用转成子类类型。
【注意】多态自始自终都是子类对象在做着类型的变化。
七、关键字 instanceof （...的实例）1、instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例，用来判断对象的具体类型，只能用于引用数据类型。 2、instanceof 通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。通常在向下转型前用于健壮性的判断。
八、Object类
1、概念：在 JDK 中提供了一个 Object 类，它是类层次结构的根类，每个类都直接或间接继承自该类，所有对象（包括数组）都实现了这个类的方法。
2、Object 类中的常用方法：
（1）toString()方法:
在测试类里直接调用toString()
在cat里面再定义一个构造方法，然后在测试类里在直接调用show方法
结果都为：
在测试里面调用
结果为：
（2）equals()方法 （用于测试两个对象是否相等。）
【注意】对于字符串来说，equals方法还可以比较两个字符串的值是否相等：
true
false
这样写也为true
九、包（Package）
1、声明包的语法格式：package 包名;
2、使用时需要注意以下四点：
（1）包名中字母必须都要小写； （2）包的命名规则：将公司域名反转作为包名； （3）package 语句必须是程序代码中的第一行可执行语句； （4）package 语句最多只有一句。包与文件目录类似，可以分成多级，多级之间用点“.”进行分割。例如：package com.sdbi.www;3、import 语句
在实际开发中，项目都是分模块开发的，对应模块包中的类，完成相应模块的功能。但有时模块之间的类要相互调用，我们就需要使用 import 语句来进行包的导入。例如： import 包名.类名; // 导入单个类 import 包名.*; // 导入包下的全部类 【注意】java 是核心包，javax 是扩展包。 十、异常处理 1、异常：在程序运行过程中，会发生各种非正常状况，在 Java 语言中，引入了异常，以异常类的形式对这些非正常情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理。 2、异常的类型： Throwable 类有两个直接的子类，Error 类和 Exception 类。其中，Error 代表程序中产生的 错误，Exception 代表程序中产生的异常。 （1）Error 类称为错误类，它表示 Java 运行时产生的系统内部错误或资源耗尽的错误，是比较严重的，仅靠修改程序本身是不能恢复执行的。 在程序中，使用 Java 命令去执行一个不存在的类就会出现 Error 错误。 （2）Exception 类称为异常类，他表示程序本身可以处理的错误。在开发 Java 程序中进行的异常处理都是针对 Exception 类及其子类。 在 Exception 类的众多子类中有一个特殊 RuntimeException 类，该类及其子类用于表示运行时异常。除了此类，Exception 类下所有其他的子类都用于表示编译时异常。 3、异常处理：try…catch与finally 格式：try {
//程序代码块
} catch( Exception 类及其子类 e ) {
//对异常的处理
}
其中在 try 代码块中编写可能发生异常的 Java 语句，catch 代码块中编写针对异常进行处理的代码。当 try 代码块中的程序发生了异常，系统会将这个异常的信息封装成一个异常对象，
并将这个对象传递给 catch 代码块。catch 代码块需要一个参数指明它所能够接收的异常类型，这个参数的类型必须是 Exception 类或其子类。
（2）在 try 语句块中，发生异常语句后面的代码是不会被执行的。但有时候，用户希望有些语句无论程序是否发生异常，都要执行，这时就可以在 try…catch 语句后加一个 finally 语句块。
4、throws 关键字
（1）Java 中允许在方法的后面使用 throws 关键字对外声明该方法有可能发生的异常，这样调用者在调用方法时，就明确地知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过。
（2）格式：修饰符 返回值类型 方法名(参数列表) throws Exceptiontype1[, Exceptiontype2]{ } （3）解决： a.使用 try…catch 语句捕获public class Yichang {
public static void main(String[] args) {
try {
int result = divide(4, 0);
System.out.println(result);
} catch (Exception e) {
e.printStackTrace(); }
System.out.println("程序继续向下执行...");
}
5
public static int divide(int x, int y) throws Exception {
int result = x / y;
return result;
} }
b.继续将异常向上抛出
如果在调用 divide 方法时，不知道如何处理声明抛出的异常，也可以使用 throws 关键字继续将异常向上抛出，这样程序编译也会通过， 但是需要注意的是，程序一旦发生异常，如果没有被处理，程序就会非正常终止。public class Yichang {
public static void main(String[] args) throws Exception {
int result = divide(4, 0);
System.out.println(result);
System.out.println("程序继续向下执行...");
}
public static int divide(int x, int y) throws Exception {
int result = x / y;
return result;
} }
5、自定义异常
（1）在 Java 中允许用户自定义异常，定义自定义异常类时需要记住下面的几点：
➢ 所有异常都必须是 Throwable 的子类。 ➢ 如果想定义一个检查性异常类，则需要继承 Exception 类。 ➢ 如果想定义一个运行时异常类，那么需要继承 RuntimeException 类。public class DivideByMinusException extends Exception {
public DivideByMinusException() {
super(); // 调用 Exception 无参的构造方法
}
public DivideByMinusException(String message) {
super(message); // 调用 Exception 有参的构造方法
} }
（2）用 throw 关键字
public class Yichang {
public static void main(String[] args) {
try {
int result = divide(4, -2);
System.out.println(result);
} catch (Exception e) { // 对捕获到的异常进行处理
e.printStackTrace(); // 打印捕获的异常信息
}
System.out.println("程序继续向下执行...");
}
public static int divide(int x, int y) throws Exception {
if (y < 0) { throw new DivideByMinusException("除数为负数！"); }
int result = x / y;
return result; //
7 } }
6、原则：在当前方法声明中使用 try-catch 语句捕获异常。
一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或其子类。 如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。标签：Exception,异常,面向对象,子类,抽象类,父类,方法 来源： https://www.cnblogs.com/Liyan510620/p/16067651.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。