自定义类

关键：
class
extents:继承 继承父类的成员和方法
类的继承不改变类成员的访问权限，也就是说，如果父类的成员是公有的、被保护的或默认的，它的子类仍具有相应的这些特性，并且子类不能获得父类的构造方法。

package review;

import java.util.Scanner;
//定义类
class juxin{
   
    private int length;
    private int weight;
    juxin(int length,int weight){
   
        this.length=length;
        this.weight=weight;
    }
    public int zhouchang(){
   
        return 2*(length+weight);
    }
    public int mianji(){
   
        return length*weight;
    }
}
public class part1 {
   
    public static void main(String[] args){
   
        Scanner input= new Scanner(System.in);
        int m=input.nextInt();
        int n=input.nextInt();
        juxin a=new juxin(m,n);
        System.out.println("周长为："+a.zhouchang());
        System.out.println("面积为："+a.mianji());
    }
}

接口

interface ：定义接口的关键字
implements：“工具”，使用接口，实现接口中的声明

一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。

接口的主要用途就是被实现类实现，一个类可以实现一个或多个接口，继承使用 extends 关键字，实现则使用 implements 关键字。因为一个类可以实现多个接口，这也是 Java 为单继承灵活性不足所作的补充。

实现接口需要注意以下几点：

• 实现接口与继承父类相似，一样可以获得所实现接口里定义的常量和方法。如果一个类需要实现多个接口，则多个接口之间以逗号分隔。

• 一个类可以继承一个父类，并同时实现多个接口，implements 部分必须放在 extends 部分之后。

• 一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。

package review;
interface dongwu{
   
	//接口体，其中可以包含定义常量和声明方法
    public void pao();
}
//接口
class bird implements dongwu{
   
    @Override
    public void pao() {
   
        System.out.println("鸟会跑");
    }
}
class fish implements dongwu{
   
    @Override
    public void pao() {
   
        System.out.println("鱼不会跑");
    }
}
public class part2 {
   
    public static void main(String[] args){
   
        bird a=new bird();
        fish b=new fish();
        a.pao();
        b.pao();
    }
}

package review;
interface dongwu{
   
    public void pao();
    public void eat();
}
//接口
abstract class bird1 implements dongwu{
   
    @Override
    public void pao() {
   
        System.out.println("鸟会跑");
    }
}
class bird extends bird1{
   
    public void eat(){
   
        System.out.println("吃虫子");
    }
}
class fish implements dongwu{
   
    @Override
    public void pao() {
   
        System.out.println("鱼不会跑");
    }
    public void eat(){
   
        System.out.println("吃小鱼");
    }
}
public class part2 {
   
    public static void main(String[] args){
   
        bird a=new bird();
        fish b=new fish();
        a.pao();
        a.eat();
        b.pao();
        b.eat();
    }
}

截图：

抽象类

abstract
抽象方法的 3 个特征如下：

• 抽象方法没有方法体
• 抽象方法必须存在于抽象类中
• 子类重写父类时，必须重写父类所有的抽象方法

在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰，因为抽象方法必须被子类重写，而如果使用了 private 声明，则子类是无法重写的。

抽象类的定义和使用规则如下：

• 抽象类和抽象方法都要使用 abstract 关键字声明。
• 如果一个方法被声明为抽象的，那么这个类也必须声明为抽象的。而一个抽象类中，可以有 0~n 个抽象方法，以及 0~n 个具体方法。
• 抽象类不能实例化，也就是不能使用 new 关键字创建对象。

抽象类中的抽象方法必须先实现才能进行重构

package review;
//抽象类
abstract class tuxin{
   
    public abstract void hua();
}
class juxin1 extends tuxin{
   
    @Override
    public void hua() {
   
        System.out.println("画一个矩形");
    }
}
class yuan extends tuxin{
   
    public void hua(){
   
        System.out.println("画一个圆");
    }
}
public class part3 {
   
    public static void main(String[] args){
   
        juxin1 a=new juxin1();
        yuan b=new yuan();
        a.hua();
        b.hua();
    }
}

package review;
//抽象类
abstract class tuxin{
   
    public abstract void hua();
    public void printy(){
   
        System.out.println("你好！");
    }
    public abstract void chong();

}
class juxin1 extends tuxin{
   
    @Override
    public void hua() {
   
        System.out.println("画一个矩形");
    }
    public void chong(){
   //注释掉会报错，表示抽象方法必须先实现才能重构
        System.out.println("矩形重写");
    }
    public void chong(String a){
   
        System.out.println(a);
    }
    public int chong(int a){
   
        return a;
    }
}
class yuan extends tuxin{
   
    public void hua(){
   
        System.out.println("画一个圆");
    }
    public void chong(){
   
        System.out.println("圆重写");
    }
}
public class part3 {
   
    public static void main(String[] args){
   
        juxin1 a=new juxin1();
        yuan b=new yuan();
        a.hua();
        a.chong();
        a.chong("矩形重载");
        System.out.println(a.chong(1));
        a.printy();
        b.hua();
        b.chong();
    }
}

截图

自定义异常类

Exception：java定义好的异常
super()关键字的功能：

• 在子类的构造方法中显式的调用父类构造方法
• 访问父类的成员方法和变量。

try catch 语句用于捕获并处理异常
finally 语句用于在任何情况下（除特殊情况外）都必须执行的代码
throw 语句用于拋出异常，throw语句后程序立即终止，她后面的语句不能执行。
throws 语句用于声明可能会出现的异常。用在方法以及构造器声明的地方。

try 后面的花括号{ }不可以省略，即使 try 块里只有一行代码，也不可省略这个花括号。与之类似的是，catch 块后的花括号{ }也不可以省略。另外，try 块里声明的变量只是代码块内的局部变量，它只在 try 块内有效，其它地方不能访问该变量。

printStackTrace() 方法：指出异常的类型、性质、栈层次及出现在程序中的位置。
getMessage() 方法：输出错误的性质。
toString() 方法：给出异常的类型与性质。

System.out.println("e.getMessage():");
System.out.println(e.getMessage());

System.out.println("e.toString():");
System.out.println(e.toString());

System.out.println("e.printStackTrace():");
e.printStackTrace();

注意：当捕获的多个异常类之间存在父子关系时，捕获异常时一般先捕获子类，再捕获父类。所以子类异常必须在父类异常的前面，否则子类捕获不到。

try catch finally 语句块的执行情况可以细分为以下 3 种情况：

• 如果 try 代码块中没有拋出异常，则执行完 try 代码块之后直接执行 finally 代码块，然后执行 try catch finally 语句块之后的语句。
• 如果 try 代码块中拋出异常，并被 catch 子句捕捉，那么在拋出异常的地方终止 try 代码块的执行，转而执行相匹配的 catch 代码块，之后执行 finally 代码块。如果 finally 代码块中没有拋出异常，则继续执行 try catch finally 语句块之后的语句；如果 finally 代码块中拋出异常，则把该异常传递给该方法的调用者。
• 如果 try 代码块中拋出的异常没有被任何 catch 子句捕捉到，那么将直接执行 finally 代码块中的语句，并把该异常传递给该方法的调用者。

throws 关键字和 throw 关键字在使用上的几点区别如下：

• throws 用来声明一个方法可能抛出的所有异常信息，表示出现异常的一种可能性，但并不一定会发生这些异常；throw 则是指拋出的一个具体的异常类型，执行 throw 则一定抛出了某种异常对象。
• 通常在一个方法（类）的声明处通过 throws 声明方法（类）可能拋出的异常信息，而在方法（类）内部通过 throw 声明一个具体的异常信息。
• throws 通常不用显示地捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法； throw 则需要用户自己捕获相关的异常，而后再对其进行相关包装，最后将包装后的异常信息抛出。

package review;

import java.util.Scanner;

//异常处理
class yichang extends Exception{
   
    public yichang(){
   
        super();
    }
    public yichang(String e){
   
        super(e);
    }
}
class juxin2{
   
    private int length;
    private int weight;
    juxin2(int length,int weight) throws yichang {
   
        if(length<=0||weight<=0){
   
            throw new yichang("边长必须大于零！");//要么处理要么抛
        }else{
   
            this.length=length;
            this.weight=weight;
        }
    }
    public void area(){
   
        System.out.println("面积为："+length*weight);
    }
}
public class part4 {
   
    public static void main(String[] args){
   
        Scanner input = new Scanner(System.in);
        int a=input.nextInt();
        int b=input.nextInt();
        try {
   
            juxin2 c=new juxin2(a,b);
            c.area();
        } catch (yichang e) {
   
            System.out.println(e.getMessage());;
            e.printStackTrace();
            System.out.println(e.toString());;
        }
    }
}

package review;

import java.util.Scanner;

//异常处理
class yichang extends Exception{
   
    public yichang(){
   
        super();
    }
    public yichang(String e){
   
        super(e);
    }
}
class juxin2{
   
    private int length;
    private int weight;
    juxin2(int length,int weight) {
   
        if(length<=0||weight<=0){
   
            try {
   
                throw new yichang("边长必须大于零！");//要么处理要么抛
            } catch (yichang e) {
   
                e.printStackTrace();
            }
        }else{
   
            this.length=length;
            this.weight=weight;
        }
    }
    public void area(){
   
        System.out.println("面积为："+length*weight);
    }
}
public class part4 {
   
    public static void main(String[] args){
   
        Scanner input = new Scanner(System.in);
        int a=input.nextInt();
        int b=input.nextInt();
        juxin2 c=new juxin2(a,b);
        c.area();
    }
}