JAVA三大核心支撑技术是怎样配合工作的? java核心技术知乎

转载

mob64ca13ff5b03 2023-09-19 05:30:16

文章标签 多态 java 编程语言 jvm 代码块 文章分类 Java 后端开发

该到重点啦—java的核心技术

文章目录

该到重点啦—java的核心技术

一、前言
二、多态
三、异常

3.1、什么是异常？
3.2、异常的分类
3.3、异常处理流程
3.4、自定义异常

一、前言

在之前一节，我们已经说过java面向对象的特性了，在这里我们就继续简单回顾一下内容，java核心技术上可以的话，最好全部重新回顾看一遍。java的面向对象技术包括三大核心模块，封装、继承、多态。在其中封装和继承比较容易理解一点。对于多态的话，我们需要好好理解一下，这一块的java核心技术是我们以后进阶大数据学习的基础，最好一定要把基础给打牢，不然的话，及时学习到后面的内容，我们也会感觉力不从心的，所有的技术都是浮于表面，我们需要把内功练好。当然
said easy than done(说来容易，做到难)，基于如此，我们先回顾一下多态内容，之后继续了解异常部分

二、多态

1、什么是多态

多态是同一个行为具有多个不同表现形式或形态的能力。例如一个人，可以是同时是数学家和物理学家。
2、多态的转型

多态的转型有向上转型和向下转型两种。

3、多态的向上转型

当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。

父类类型变量名=new 子类类型()

4、向下转型

当要使用子类特有功能时。
子类类型变量名=（子类类型）父类类型的变量；
示例代码：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

三、异常

3.1、什么是异常？

异常是程序中的一些错误使得程序没有按照预期正常执行。Java提供了异常处理机制处理异常问题。

异常处理机制可以让程序在发生异常时，按照预先设计的逻辑处理异常。

产生异常的原因有很多，通常是：

用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。

异常的类型有以下三种：

**检查性异常：**最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

3.2、异常的分类

异常处理的根接口是Throwable，有两个子接口，分别是Error和Exception。

Error：用来指示运行时环境发生的错误，这是系统错误类，一般开发人员无法处理，只能关闭程序。

Exception：指的是程序运行中产生的异常。

Exception下的异常分为两大类，分别是Runtime异常和非Runtime异常

Runtime异常：程序运行时产生的异常，jvm会自动处理。典型的运行时异常有：数组下标越界异常（IndexOutOfBoundsException）、空指针异常（NullPointerException）、对象类型强制转换异常（ClassCastException）以及数组存储异常（ArrayStoreException，即数组存储类型不一致）等。

非Runtime异常：也叫检查异常，即编译器要求必须进行处理的异常，例如IOException、SqlException。

3.3、异常处理流程

Java异常机制用到的几个关键字：try、catch、finally、throw、throws。

try: 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
catch：用于捕获异常。catch用来捕获try语句块中发生的异常。
finally：finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。
throw：用于抛出异常。
throws：用在方法签名中，用于声明该方法可能抛出的异常。主方法上也可以使用throws抛出。如果在主方法上使用了throws抛出，就表示在主方法里面可以不用强制性进行异常处理，如果出现了异常，就交给JVM进行默认处理，则此时会导致程序中断执行。
产生异常的原因：

try-catch

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

try-catch-finally

finally 关键字用来创建在 try 代码块后面执行的代码块。

无论是否发生异常，finally 代码块中的代码总会被执行。

在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

finally 代码块出现在 catch 代码块最后，语法如下：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

throws/throw

如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

下面方法的声明抛出一个 RemoteException 异常：

import java.io.*; 
public class className {  
    public void deposit(double amount) throws RemoteException  
		{    // Method implementation    throw new RemoteException();  }  //Remainder of class definition }

一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

例如，下面的方法声明抛出 RemoteException 和 InsufficientFundsException：

import java.io.*; 
public class className {  
	public void withdraw(double amount) throws RemoteException,
	   InsufficientFundsException   { 
	    // Method implementation   
	    }   //Remainder of class definition }