java if 三元判断 java三元符

第一章 计算机认识

1 概述

计算机包括**硬件（hardware）和软件（software）**两部分。硬件包括计算机可以看得见的物理部分，而软件提供看不见的指令。

2 计算机硬件介绍

3 计算机硬件——中央处理器

中央处理器（central Processing Unit，CPU）是计算机的大脑，它是从内存中获取指令，然后执行这些指令。

4 计算机硬件介绍——存储设备

• 内存中的信息在断电时会丢失
• 磁盘驱动器：每台计算机至少有一个磁盘驱动器。硬盘（hard disk）用于永久的保存数据和程序

5 比特（bit）和字节（byte）

• 一个0或者一个1存储为一个比特 （bit），是计算机最小的存储单位
• 计算机最基本存储单元是字节（byte），每个字节由8个比特（bit）构成

6 内存

内存（random-Access Memory，RAM）：由有系的字节序列组成，用于存储程序及程序需要的数据。

一个程序和它的数据在被CPU加载执行前移到计算机的内存中。

7 硬件——输入和输出设备

常见输入：键盘（keyboard）、鼠标（mouse）

常见输出：显示器（monitor）、打印机（printer）

8 计算机发展史上鼻祖

阿兰·图灵 和 冯若依曼

9 操作系统

操作系统（operating System）是运行在计算机上的最重要的程序，它可以管理和控制计算机的活动。

操作系统的主要任务：

• 控制和监控系统的活动
• 分配和调配系统资源
• 调度操作

第二章 Java入门体验

1、Java特点

• 特点一：面向对象

• 基本特点：类、对象
• 三大特性：封装、继承、多态

• 特点二：键壮性
• 特点三：跨平台

• 通过java编写应用程序在不同系统都可以运行。“一次编译到处运行”

2、什么是JDK、JRE

（1）JDK是提供给Java开发人员使用的，其中包含Java开发工具包，同时也包括了JRE。

（2）JRE是指Java运行环境，包含了JVM+Javase核心内库

3、Java开发体验——hallo world

class HelloChina{
  public static void main(String[] args){
    system.out.println("Hello,World");
  }
}

Java执行步骤：

第一步：将Java代码编写到扩展名为.java的文件，称为Java源文件

第二步：通过Javac命令对该Java源文件进行编译格式：javac HelloChina.java

第三步：使用java.exe命令解释运行我们字节码文件，格式：java 类名

4、注释（Comment）

注释是为了对程序 进行一个解释说明，增强可读性，方便自己和他人可读。

（1）单行注释使用：

（2）多行注释使用：/*回车即可注释多行*/

（3）文档注释（Java特有的）使用格式：

/**
 @authr 指定Java程序作者
 @version 指定源文件版本
*/

第三章 Java基本语法

1、变量

• 变量概念：内存中的一个存储区域，该区域的数据可以在同一个类型范围不断变化。变量是程序最基本的存储单元。
• 变量作用：用于在内存中保存数据
• Java 定义变量的格式：数据类型 变量名 = 变量值;

2、数据类型

Java是一种强类型语言，共有8 种基本类型，其中有 4 种整型 、 2 种浮点类型 、 1 种用于表示 Unicode 编码的字符单元的字符类型 char 和 1 种用于表示真值的 boolean 类型。

（1）整数类型：byte、short、int、long

类型

占用存储空间

范围

（2）浮点型

类型

占用存储空间

范围

注意：Java浮点型常用默认为double，声明float型常量必须加“f”或“F”

（3）字符类型：char（1字符=2个字节）

char c1 = '小';
System.out.println(c1);

注意：定义char型变量，内部只能写一个字符。

（4）布尔值：boolean

• 只能取两个值：true和false，常常用于判断、循环结构中使用，简单如下：
  boolean bl = true;
  if (bl) {
  System.out.println("不能去上课！");
  }else {
  System.out.println("去上课！");
  }

3、强制类型转换

• 自动类型提升运算的逆向运算
• 如何强转：就是将范围大数据类型转到小的数据类型
• 注意点：可以导致精度损失

double d1 = 12.9;
int i1 = (int) d1;
System.out.println(i1);
运行结果：
12

4、引用类型：String

• String是定义在 java.lang 包下的一个类，String是不可变的，JVM使用字符串池来存储所有的字符串对象。
• String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+,如下

• int age = 23;
  String name = "小何同学";
  String info = name + ",今年" + age + "岁";
  System.out.println(info);

面试题：为什么String设计为不可变？

（1）字符串常量池的需要：当创建一个String对象时,假如此字符串值已经存在于常量池中,则不会创建一个新的对象,而是引用已经存在的对象。

（2）保证了hash码的唯一性

（3）避免安全问题：在网络连接和数据库连接中字符串常常作为参数，例如，网络连接地址URL，文件路径path，反射机制所需要的String参数。其不可变性可以保证连接的安全性。如果字符串是可变的，黑客就有可能改变字符串指向对象的值，那么会引起很严重的安全问题。

5、运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较
算术运算符、赋值运算符、比较运算符（关系运算符）、逻辑运算符、位运算符、三元运算符

（1）算术运算符（以下列出比较难一点的运算符）

运算符

运算

范例

结果

（2）逻辑运算符

&—>逻辑与、|—>逻辑或、！—>逻辑非
&&—>短路与、||—>短路或、^—>逻辑异或

（3）位运算符

运算符

运算

范例

• <<：在一定范围内，每向左移1位，相当于乘2
• >>：在一定范围内，每向右移1位，相当于除2

（4）三元运算符

• 结构：(条件表达式)？表达式1:表达式2
• public class Test1 {
  public static void main(String[] args) {
  int m = 12;
  int n = 5;
  int max = (m > n) ? 3:2; //如果m > n，输出3，否则输出2
  System.out.println(max);
  }
  }

（5）运算符优先级

6、程序流程控制

（1）if-else

（2）如何从键盘获取scanner

• public class Test1 {
  public static void main(String[] args) {
  Scanner sca = new Scanner(http://System.in);
  System.out.println("请输入名字：");
  String next = sca.next();
  System.out.println("请输入年龄：");
  int i = sca.nextInt();
  if (i > 18) {
  System.out.println(next + ",恭喜，骑共享汽车");
  }else {
  System.out.println(next + ",未满18岁，不能骑车");
  }
  }
  }

（3）switch-case

• public class Test2 {
  public static void main(String[] args) {
  int numder = 2;
  switch (numder) {
  case 0:
  System.out.println("zero");
  case 1:
  System.out.println("one");
  case 2:
  System.out.println("two");
  break;
  case 3:
  System.out.println("ffff");
  default:
  System.out.println("结束");
  }
  }
  }/*说明：1、根据switch表达式中值，一次匹配case中常量，一旦匹配成功则进入相应case结构中。当调用完执行语句后，则仍然继续向下执行其它语句case中语句，直到遇到break关键字或者switch-case结构末尾结束为止。2、switch结构中表达式只能是以下6种数据类型之一：byte、short、char、int、枚举类型（1.5新增）、String类型（1.7新增）*/

（4）for循环

水仙花数

public class Test2 {
    public static void main(String[] args) {
        for (int i = 100; i < 1000;i++) {
            int ge = i % 10;
            int shi = i % 100 /10;
            int bai = i / 100;
            if (i == ge*ge*ge + shi*shi*shi + bai*bai*bai) {
                System.out.println("水仙花数：" + i);
            }
        }
    }
}

（5）while循环

public class Test2 {
    public static void main(String[] args) {
        //变量100内偶数
        int i = 1;
        while (i <= 100) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
            i++;
        }
    }
}

（6）do-while

while是先判断在做，而do-while先做在判断，至少执行一次

（7）特殊关键字的使用：break、continue

• break：结束当前循环
• continue：结束当次循环

for (int i =1; i <= 10; i++) {
            if (i %4 == 0) {
                //break;//1、2、3
                continue;//1、2、3、5、6、7、8、9、10
            }
            System.out.print(i + " ");
        }

第四章 数组

1、一维数组的使用

• int[] name = {1,4,3,2,5,6,8};
• Java数组的索引是从0开始的，到数组的长度-1结束。

2、如何获取数组长度以及遍历数组

public class ArrayTest1 {
    public static void main(String[] args) {
        int[] num = {1,4,3,2,8,6};
        System.out.println(num.length);//获取长度
        //遍历数组的每个元素
        for (int s: num){
            System.out.print(s + " ");
        }
    }
}

3、多维数组的使用

int[][] arr = {{5},{5}};
        //1、获取数组指定位置元素
        System.out.println(arr[0][0]);
        //获取多维数组长度
        System.out.println(arr[0].length);//第一行的元素
        //3、如何遍历二维数组
        for (int i = 0; i < arr.length;i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

4、随机数

公式：Math.random()*(n-m + 1)+m，生成大于等于m小于n的随机数；

5、数组复制、数组反转

String[] arr = {"詹姆斯","浓眉","科比","威少","哈登"};
        //复制数组
        String[] arr1 = new String[arr.length];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr[i];
        }
        //数组反转方式1
        for (int i = 0; i < arr.length / 2; i++) {
            String temp = arr[i];
            arr[i] = arr[arr.length - i -1];
            arr[arr.length - i -1] = temp;
        }
        //反转方式二
        for (int i = 0, j  = arr.length -1; i < j; i++,j--) {
            String temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "t");
        }

6、查找（线性查找和二分查找）

（1）线性查找

public class ArrayTest3 {
    public static void main(String[] args) {
        String[] arr = {"詹姆斯","浓眉","科比","威少","哈登"};
        //查找
        Scanner scanner = new Scanner(System.in);
        System.out.println("请出入：");
        String dest = scanner.next();
        boolean isFlag = true;
        for (int i = 0; i < arr.length; i++) {
            if (dest.equals(arr[i])) {
                System.out.println("找到之指定元素位置为：" + i);
                isFlag =  false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("对不起，没有找到！");
        }
    }
}

（2）二分查找

public class ArrayTest3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //二分查找
        //使用二分法查找前提是必须有序
        int[] arr2 = {-1,2,4,5,6,7,8,9,11,12};
        System.out.println("请出入你要找的值：");
        int index = scanner.nextInt();
        int head = 0;
        int end = arr2.length - 1;
        boolean isFlag1 = true;
        while (head <= end) {
            int mid = (head + end) / 2;
            if (index == arr2[mid]) {
                System.out.println("恭喜找到了，位置为：" + mid);
                isFlag1 = false;
                break;
            } else if (arr2[mid] > index) {
                end = mid - 1;
            } else {
                head = mid +1;
            }
        }
        if (isFlag1) {
            System.out.println("对不起，没有找到");
        }
    }
}

7、数组异常

（1）数组角标越界的异常：ArrayIndexOutOfBoundsException

（2）空指针异常：NullPointerException

第五章 对象与类

1、类 与 对象

• 类（class）对象（Object）是面向对象核心概念。

• 类是对一类事物的描述，是抽象的、概念上的定义
• 对象是实际存在该类事物的每个个体

2、对象内存解析

（1）堆（Heap）：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。（JVM规范描述：所有对象实例以及数组都在堆上分配）

（2）虚拟机栈（stack）：用于存储局部变量等。局部变量表达存放类编译期可知长度的各种基本数据类型（byte、short、int、long、double、float、boolean、对象引用）。方法执行完自动释放。

（3）方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译后的代码等数据。

3、属性与局部变量的对比

（1）不同点：

• 属性直接定义在类的一对{}内，而局部变量声明在方法内、方法形参、代码块内、构造器内部的变量。
• 属性可以在声明时指明权限问题，局部变量不可以使用权限修饰符。
• 属性加载到堆空间中的，而局部变量加载到栈空间。

4、方法重载（OverLoadTest）

（1）重载概念

• 在同一个类中，允许存在一个以上同名方法，只要它们的参个数或者参数类型不同即可。

（2）方法参数的值传递机制

• 如果参数是基本数据类型，此时实参数赋给形参真实存储的数据值。
• 如果参数是引用数据类型，此时实参数赋给形参真实存储的地址值。

（5）递归方法的使用

• 递归方法：一个方法体内调用它自身
• 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无必循环控制
• 递归一定要axing已知方向递归，否则这种递归就变成了无穷递归，类似死循环。

public static int getSum(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n + getSum(n - 1);
        }
    }
    public static int getSum1(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * getSum(n - 1);
        }
    }

5、构 造 器

构造器作用：创建对象

6、JavaBean

• JavaBean是一种Java语言写成的可重用组建
• 所谓JavaBean，是符合以下标准的Java类

• 类是公共的
• 有一个无参的公共构造器
• 有属性，且有对应的get、set方法

7、关键字 this 使用

第六章 继承

继承性、多态性。

1、继承能解决什么问题？

• 主要解决问题就是：共性抽取

2、继承特点

• 子类可以拥有父类的“内容”
• 子类还可以拥有自己专有的“内容”

3、方法重写（Override/Overwinter）

• 定义：

• 在子类中可以根据需要对父类中继承来的方法进行改造，称之为方法重置、覆盖

• 要求：

• 子类重写的方法 必须和父类被重写方法具有相同的方法名称、参数列表
• 子类重写方法的返回值类型不能大于父类被重写的方法返回值
• 子类重写父类的方法使用的访问权限不能小于父类被重写的方法访问权限（子类不能重写父类声明为private权限方法）
• 子类方法抛出异常不能大于父类被重写方法异常

• 注意：

• 子类和父类中同名参数的方法必须同时声明为非static的活着同时声明为static

4、类、超类、子类

5、equals方法

Object 类中的 equals 方法用于检测一个对象是否等于另外一个对象。在 Object 类中 这 ，这个方法将判断两个对象是否具有相同的引用。如果两个对象引用相等那么它们一定是相等的。

第七章 多态

1、多态栗子

（1）新建person类（父类）

public class Person {
String name;
int age;
public void eat() {
  System.out.println("人，吃饭");
}
public void walk() {
  System.out.println("人，走路");
 }
}

（2）男人类（子类）

public class Man extends Preson{
  boolean isMoking;
  public void earnMoney() {
    System.out.println("男人挣钱养家");
  }
  //从父类重写的方法
  public void eat() {
  System.out.println("人，吃饭");
}
public void walk() {
  System.out.println("人，走路");
}
}

（3）女人类

public class Woman extends Person {
  boolean isBeauty;
  public void goShopping() {
    System.out.println("女人喜欢购物");
  }
  //从父类重写的方法
  public void eat() {
  System.out.println("女人少吃是为了减肥");
}
public void walk() {
  System.out.println("女人窈窕的走路");
}
}

（4）面向对象特征之三：多态

public calss PersonTest{
  public static void mian(String[] args) {
    Person p1 = new Person();
    p1.eat();
    Man man = new Man();
    man.age = 25;
    //对象的多态
    Person p2 = new Man();
    p2.eat();//多态的使用是调用子类的重写的方法---虚拟方法使用
    Person p3 = new Woman();
  }
}

总结：对象的多态性：是指父类的引用指向子类的对象。（或者子类 的对象赋给父类的引用）

注意：在我们编译期，只能调用父类中声明的方法，但是在运行期中，我们实际执行的是子类的重写父类的方法

小结：编译看左边、运行看右边。

2、Object 类的使用

（1）==

• 如果比较的是基本数据类型变量，比较两个变量保存的数据是否相等
• 如果比较的引用数类型变量，比较的是对象的地址值是否相同

（2）equals

• 像string、date、file、包装类等都重写Object类中的equals方法。重写以后比较的不是两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相等。
• 通常情况下，自定义的类如果使用equals的话，也通常是比较两个对象“实体内容”是否相同，那么需要对Object进行重写。

为什么需要重写equals()方法？因为如果直接调用equals方法的话是使用Object类的equals的，是比较地址是否相等。而我们需要进行比较两个引用的内容是否相等是需要重写equals方法。

（3）toString方法

• 当我要输出一个对象引用时，实际上就是调用当前对象的toString
• 使用toString时是指，返回“实体内容”信息

3、单元测试

步骤：

（1）选中当前工程-右键选择：build path - add libraries - JUnit 4 -下一步

（2）创建家吧类进行单元测试：此时Java要求：此类是public的、此类提供无参的构造器

（3）此类中声明单元测试方法：此时单元测试方法：方法的权限是public，没有返回值，没有形参

4、关键字 Static

• static可以使用来修饰：属性、方法、代码块、内部类
• static修饰属性：静态变量（不使用static修饰的称实例变量）

• 静态变量随着类加载而加载。可通过“类”静态变量的方式进行调用
• 静态变量的加载要早于对象的创建
• 由于类只会加载一次，则静态变量的内存中也只会保存一份，存在方法区的静态域中

• static修饰方法：静态方法

• 随着类的加载而加载。可以通过“类”点调用静态方法即可。
• 静态方法中：只能调用静态的方法或属性；而非静态方法既可以调用非静态方法或属性，也可以调用静态的方法或属性。
• static使用细节：在静态的方法内不能使用this关键字、super关键

• 在开发中如何确定一个属性和方法是否要声明为static关键字？

• 属性是可以被多个对象所共享的，不会随着对象的不同而不同
• 操作静态属性的方法，通常设置为static；工具类中的方法使用static比如：Math、Arrays、Collection等

5、代码块（开发使用频率不算高）

（1）代码块的作用：用来初始化类、对象

（2）代码块如果修饰的话，只能使用static

（3）分类：静态代码块、非静态代码块

//静态代码块
static {
  System.out.println("Static code block");
}
//非静态代码块
{
  System.out.println("Not Static code block");
}

总结：

• 静态代码块：

• 内部可以有输出语句
• 随着类的加载而执行，而且只加载一次
• 作用：初始化类的信息
• 如果一个类总定义多个静态代码块，则按照顺序进行执行

• 非静态代码块：

• 内部可以有输出语句
• 随着对象的创建而执行
• 每创建一个对象，就执行一次非静态代码块
• 作用：可以在创建对象时，对对象的属性等进行初始化

6、关键字 final

• final可以修饰的结构：类、方法、变量
• final修饰一个类时，此类不能被其它类继承
• final修饰变量时，此时的“变量”就称为一个常量，声明为final的变量就不能被改变了
• final修饰属性：可以考虑赋值的位置有（显示初始化、代码块中初始化、构造器中初始化）
• 修饰局部变量：当修饰形参时，表明型参是一个常量。当修饰方法时，给常量型参赋一个是参
• static final 用来修饰属性时：称为全局常量（static随着类加载而加载，final常量）

7、抽象类与抽象方法

• abstract可以修饰的结构：类、方法（不能修饰：属性、构造器、私有方法、静态方法、final的类和方法）
• abstract修饰类时：抽象类

• public class PersonTest {
  public static void main(String[] args) {
  Person1 p1 = new Person1();//一旦Person1类抽象了，就不可实例话
  }
  }
  abstract class Person1 {}

• 修饰方法时：称为抽象方法（抽象方法只有方法的声明，没有方法体）

• public abstract void eat();
• 注意1：包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法
• 注意2：若子类重写父类中所有抽象方法，此子类方可实例化；若子类没有重写父类中所有抽象方法，则子类也是一个抽象类，需要使用abstract修饰

8、接口（interface）

1. Java不支持多重继承，所有提供类接口，这样就可以得到多重继承的效果。
2. 接口的具体使用，体现多态性
3. 接口，实际上可以看作一个规范

（1）如何定义接口：定义接口的成员

• JDK7以前：只能定义全局常量和抽象方法

• public class PersonTest {
  public static void main(String[] args) {
  int maxSpeed = Flyable.MAX_SPEED;
  System.out.println(maxSpeed);
  }
  }
  interface Flyable {//全局常量
  public static final int MAX_SPEED = 800;
  int MIN_SPEED = 1;//public static final可以省略不写//抽象方法
  public abstract void fly();
  }

• JDK8，除了定义全局变量以及抽象方法之外，还可以定义静态方法 和 默认方法

• public interface CompareTest {//静态方法
  public static void method1() {
  System.out.println("Hello,静态方法。");
  }//默认方法
  public default void method2() {
  System.out.println("Hello,default1");
  }
  default void method3() {
  System.out.println("Hello,default2");
  }
  }
  class CompareA implements CompareTest{
  }
  class Test{
  public static void main(String[] args) {
  CompareA compareA = new CompareA();
  compareA.method2();
  CompareTest.method1();//接口的静态方法只能通过接口去调用
  }
  }

• 注意：接口不能定义构造器，也就意味着接口不可以实例化

（2）Java开发中，接口通过类去实现（implement）的方式类使用

• 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
• 如果实现类没有覆盖接口所有抽象方法，则此时实现类仍为一个抽象类

（3）Java可以实现多个接口

interface Flyable {
    void fly();
}
interface Bullet {
    void fey();
}
class Plane implements Flyable,Bullet {
    @Override
    public void fly() {
        System.out.println("涂涂，起飞！！！");
    }
    @Override
    public void fey() {
        System.out.println("✈️");
    }
}
public class PersonTest {
    public static void main(String[] args) {
        Plane plane = new Plane();
        plane.fly();
        plane.fey();
    }
}

（4）接口的具体使用，体现多态性

public class USBTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        //创建类接口非匿名实现类的非匿名对象
        Flash flashUSB = new Flash();
        computer.transFerData(flashUSB);
        //创建类接口的匿名实现的匿名对象
        computer.transFerData(new Printer());
    }
}
class Computer {
    public void transFerData(USB usb) {
        usb.start();
        System.out.println("具体传输内容");
        usb.stop();
    }
}
interface USB{
    void start();
    void stop();
}
class Flash implements USB{
    @Override
    public void start() {
        System.out.println("U盘开启工作");
    }
    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }
}
class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开启工作");
    }
    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

面试题：抽象类与接口有哪些异同？

9、内部类

开发常用的方式一：

//返回一个实现类Comparable接口的类的对象
    public Comparable getComparable(){
        //创建一个实现类Comparable接口的类:局部内部类
       //方式一
        class MyComparable implements Comparable {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
      return new MyComparable();
    }

方式二：匿名方式

public Comparable getComparable(){
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }

第七章 异常处理

1、异常概述

Java程序在这执行过程中所发生的异常事件可分为两类

• Error：Java虚拟机无法解决的严重问题。如JVM系统内部错误、资源耗尽等严重情况（stackoverFlowError和OOM）
• Exception：其它因编程错误或偶然的外在原素导致一般性问题。


2、异常处理机制一：try-catch-finally

使用try-catch-finally处理编译异常，是程序在编译时在报错，但是运行时仍可能报错，相当于使用try-catch-finally将一个编译可能出现的异常，延迟到运行时出现。

finally：是可选的，在finally中声明的代码是一定会执行。即使catch中出现异常。

3、异常处理机制二：throws+异常类型

throws+异常类型，写在方法的声明处，指明此方法执行是，可能抛出异常。一旦方法体执行出现异常仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型是，就会被抛出。

4、开发中如何选择try-catch-finally或throws

（1）如果父类中被重写的方法没有throws方法处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法有异常，必须使用try-catch-finally方法处理

5、手动抛出异常

public class ErrorTest {
    public static void main(String[] args) {
        Student student = new Student();
        try {
            student.regist(-100);
            System.out.println(student);
        } catch (Exception e) {
            //e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
}
class Student {
    private int id;
    public void regist(int id) throws Exception{
        if (id > 0) {
            this.id = id;
        }else {
            //手动抛出异常
            //throw new RuntimeException("对不起，输入数据非法！");
            throw new Exception("对不起，输入数据非法！");
        }
    }
    @Override
    public String toString() {}

6、用户自定义异常类

//自定义异常类
public class MyException extends RuntimeException {
    static final long serialVersionUID = -7034897190745766939L;//标志MyException类的
    //异常信息
    private String message;
    public MyException() {}
    public MyException(String message) {
        super(message);//构造函数调用了super(message),不用重写getMessage()方法了
        this.message = message;
    }
}

然后直接调用即可了，这里不演示了，如有疑问留言。

异常总结

面试题：throw 和 throws的区别？

throw表示方法内抛出某种异常对象，而throws方法的定义上使用 throws 表示这个方法可能抛出某种异常，需要由方法的调用者进行异常处理。