java 基础

news2024/12/24 9:43:05

第一章 计算机认识

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(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:其它因编程错误或偶然的外在原素导致一般性问题。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ETRYXB0e-1683641087696)(/Users/dimitri/Library/Application Support/typora-user-images/image-20201108175539024.png)]

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 表示这个方法可能抛出某种异常,需要由方法的调用者进行异常处理。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/507269.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

PyQGIS 加载单个shp文件到图层面板

打开QGIS Desktop 3.22.16&#xff0c;点击菜单栏 【设置】——>【Python控制台】 在Python控制台中点击【显示编辑器】按钮&#xff0c;打开Python编辑器 点击第一个按钮 【打开脚本文件】&#xff0c;选择加载图层列表到图层面板源码 # 加载图层列表到图层面板中 from qgi…

DataGridXL中快速搜索单元格和底部全屏模式区域隐藏

DataGridXL表格是在2020年发布&#xff0c;DataGridXL在设计时就考虑到了性能。提供最快、最简单、最可靠的数据网格。DataGridXL支持所有常用所有的浏览器&#xff0c;为 Web 应用程序提供类似于 Microsoft Excel 的体验&#xff0c;它支持前端框架有Vue、React、Angular等。 …

Acid burn(★★)

运行程序 先是弹出一个neg 然后是真正的程序界面 有一个输入Serial和Name的判断 还有一个只输入Serial的判断 查壳 没有壳&#xff0c;是Delphi程序 先除去一个Neg 找到Neg弹出的程序&#xff0c;在程序头下个断&#xff0c;运行程序&#xff0c;此时栈顶是调用此功能的…

希亦、米家、必胜家用洗地机测评,洗地机十年老用户告诉你哪款好用

如今&#xff0c;各种清洁设备早已进入我们的生活。其中&#xff0c;各种扫地机和洗地机更是出现在各大商场、酒店、餐饮、医院等领域。 洗地机是一种集洗地、吸尘于一体的清洗设备&#xff0c;它适合清扫如粉尘、烟头、纸屑、厨余、毛发等垃圾。它的工作效率高&#xff0c;可…

如何解决 :libstdc++.so.6: version `GLIBCXX_3.4.30‘ not found

在使用 python 以下的命令时&#xff0c; from scipy.signal import convolve出现报错&#xff1a; /home/anaconda3/envs/norm/lib/python3.9/site-packages/scipy/linalg/../../../../libstdc.so.6: version GLIBCXX_3.4.30 not found (required by /home/anaconda3/envs/no…

上海车展有哪些让人过目不忘的电驱技术?

前言 2023年的第二十届上海国际汽车工业展览会&#xff08;以下简称“上海车展”&#xff09;中&#xff0c;扁线、SiC、800V、油冷成为了大多数车企电驱动力总成的标配。下面选取几家非常有特色的电驱技术进行解析&#xff0c;并探讨下电驱技术的发展方向。 舍弗勒对标件电驱…

前几天面了个32岁的测试员,年薪50w问题基本都能回答上,应该刷了不少八股文···

互联网行业竞争是一年比一年严峻&#xff0c;作为测试工程师的我们唯有不停地学习&#xff0c;不断的提升自己才能保证自己的核心竞争力从而拿到更好的薪水&#xff0c;进入心仪的企业&#xff08;阿里、字节、美团、腾讯等大厂.....&#xff09; 所以&#xff0c;大家就迎来了…

2023.05.09-使用AI克隆孙燕姿的声音来进行唱歌

文章目录 1. 简介 2. 资源合集 3. 准备数据集3.1. 人声分离3.2. 音频进行切片化处理3.2.1. 3.3. 数据集存放格式要求 4. 训练4.1. 启动web UI.bat 4.2. 识别数据集4.3. 数据预处理4.4. 设置训练超参数4.4.1. 选择模型分支 4.5. 进行训练4.5.1. 关于显存的说明 5. 推理5.1. 加载…

从bootanimation出发分析OpenHarmony下Gralloc buffer管理机制

从bootanimation出发分析OpenHarmony下Gralloc buffer管理机制 引言 这个文档主要记录从bootanimation角度出发&#xff0c;分析OpenHarmony下对gralloc buffer的管理&#xff01;由于OpenHarmony图形子系统过于复杂&#xff0c;且个人由于能力有限&#xff0c;这里我仅从grall…

玩机搞机--定制系统 隐藏app桌面图标 反编译app【二】

在定制rom的过程中。客户要求内置某些app。个别需求内置的app不能显示在桌面&#xff0c;那么对应的内置app方法就不做细阐述。可以参考原固件操作 那么今天主要讲下隐藏app的操作解析 &#x1f494;&#x1f494;&#x1f494;&#x1f494;&#x1f494;&#x1f494;&#…

C++知识点 -- C++的类型转换

C知识点 – C的类型转换 文章目录 C知识点 -- C的类型转换一、C语言中的类型转换二、C的强制类型转换1.static_cast2.reinterpret_cast3.const_cast4.dynamic_cast 一、C语言中的类型转换 void test() {int i 0;//隐式类型转换&#xff08;意义相近的类型&#xff09;double …

只下载rpm包而不安装(用于内网虚拟机使用)

这里写目录标题 问题&#xff1a;解决&#xff1a;1. 安装yum-utils2. 下载rpm包3. 将rpm包拷贝到离线的虚拟机并安装 问题&#xff1a; 公司虚拟机仅使用内网无法通过yum下载依赖&#xff1b; 解决方法之一就是从一台连了公网的虚拟机(NAT) 下载需要的rpm包&#xff0c;然后…

Xcode安装与配置

安装Xcode Xcode需要macOS系统上安装&#xff0c;截止到2020年1月31日&#xff0c;最新版本为11.3.1。你可以选择在苹果开发者网站下载Xcode安装文件或去苹果应用市场安装&#xff0c;无论哪种方式安装Xcode&#xff0c;都需要有一个自己的Apple ID&#xff0c;具体的申请注册流…

unittest 测试框架的使用

文章目录 1. unittest 框架解析2. 批量执行测试脚本1&#xff09;构建测试套件addTest() 方法makeSuite() 方法TestLoader() 方法 2&#xff09;用例的执行顺序3&#xff09;忽略测试用例的执行 3. unittest 断言4. HTML 报告生成5. 异常捕获与错误截图6. 数据驱动1&#xff09…

【项目测试报告】网页版博客系统 + online 好友聊天室

网页版博客系统 online 好友聊天室&#xff08;项目介绍&#xff09; 实现一个网页版的博客系统&#xff0c;提供了一个技术文章论坛&#xff0c;同时也提供了用户之间在线交流的平台。 网页博客系统支持以下核心功能&#xff1a; 用户注册、登录、注销功能&#xff08;登录…

JAVAWeb11-服务器渲染技术 -JSP-02-EL表达式(会使用)

1. EL 表达式介绍 EL 表达式全称&#xff1a;Expression Language&#xff0c;是表达式语言EL 表达式主要是代替 jsp 页面的表达式脚本<%request.getAttribute("xx")%>EL 表达式输出数据时&#xff0c;比 jsp 的表达式脚本简洁EL 表达式基本语法&#xff1a; …

HAL库版FreeRTOS(下)

目录 FreeRTOS 事件标志组FreeRTOS 事件标志组简介FreeRTOS 事件标志组相关API 函数FreeRTOS 事件标志组实验功能设计软件设计下载验证 FreeRTOS 任务通知FreeRTOS 任务通知简介任务通知的优势任务通知的缺点 FreeRTOS 任务通知相关API 函数 FreeRTOS 事件标志组 事件标志组与…

【Leetcode】241. 为运算表达式设计优先级

241. 为运算表达式设计优先级&#xff08;中等&#xff09; 解法一&#xff1a;分治法 对于这道题&#xff0c;加括号其实就是决定运算次序&#xff0c;所以我们可以把加括号转化为&#xff0c;「对于每个运算符号&#xff0c;先执行处理两侧的数学表达式&#xff0c;再处理此…

提高APP安全性的必备加固手段——深度解析代码混淆技术

APP 加固方式 Android APP 加固是优化 APK 安全性的一种方法&#xff0c;常见的加固方式有混淆代码、加壳、数据加密、动态加载等。下面介绍一下 Android APP 加固的具体实现方式。 混淆代码&#xff1a; 使用 ProGuard 工具可以对代码进行混淆&#xff0c;使得反编译出来的代…

makefile语法解析

gcc语法简介 gcc (-c) hello.c world.c -o main-c表示只编译不链接 -o目标文件 此外&#xff0c;还有-I&#xff08;大写的I&#xff09;表示给gcc添加自定义的头文件的路径 -L表示给gcc添加额外的搜索库的路径 -g选项的意义是“生成调试信息&#xff0c;该程序可以被调试器调…