Java复习重点（基础知识）

Java复习重点（基础知识）

Java入门

Java运行环境（Java Runtime Environment，JRE）包括了Java虚拟机（java Virual Machine，JVM）、类库以及一些核心文件。

Java语言的源程序（.java文件）针对JVM编译后生成Java字节码文件（.class文件），然后该字节码文件可以在安装有JRE的各种操作系统上运行。

Sun公司于1995年5月推出JDK（Java Development Kit，Java开发工具）的1.0a2版本，标志着java的诞生。

Java平台：

​ ①Java SE：Java标准版平台，用于开发桌面应用程序和低端的服务器应用程序。

​ ②Java EE：Java企业版平台，用于构建企业级的应用服务，包含了Java SE并增加了附加类库。

​ ③Java ME：Java微型版平台，用于移动和嵌入式设备上应用程序的开发。

Java编译器是javac.exe能够将java源文件编译为.class的Java字节码文件。

Java虚拟机中的Java解释器是Java.exe能够解释执行Java字节码文件。

Java应用程序的基本结构

面向对象的一个重要思想就是通过抽象得到类，将某些数据（类属性）与数据上的操作（类方法）封装在一个类中。

一个Java应用程序（工程）由若干个类所构成，这些类可在一个源文件或分布在多个源文件中。但仅有一个主类（含有main方法的类），Java应用程序需从主类的main方法开始执行。

Java允许在一个源文件中编写多个类，但最多只能有一个类使用public来修饰，且源文件的文件名需与public修饰的类的名称完全相同。若无public类则需与多个类中其中一个的名称完全相同。

标识符与简单数据类型

Java标识符的语法规则：
①标识符由数字、字母、下划线和美元符号（$）组成，长度不受限制。

​ ②标识符的第一个字符不能为数字。

​ ③标识符不能与关键字相同，也不能为true、false和null（虽然它们不为关键字）。

Java语言8种简单数据类型：

​ ①整数类型：int、byte、short、long。

​ ②浮点类型：float、double。

​ ③字符类型：char。

​ ④逻辑类型：boolean。

int型（占四个字节），取值范围为-2^31~231-1，例：123（十进制）、012（八进制）、0x12C（十六进制）。

byte型（占一个字节），取值范围为-2^7~27-1，例：（byte）12。

short型（占两个字节），取值范围为-2^15~215-1，例：（short）28。

long型（占八个字节），取值范围为-2^63~263-1，例：12L，0127L，0xA23L。

float型（占四个字节），存储时保留8位有效数字，例：12.34f，12.34F，1e-5f。

double型（占八个字节），存储时保留16位有效数字，例：12.34d，12.34D（d/D可省略不写），1e-28。

数据转换时的类型精度排序：

​ 低---------------------------------------------------------->高

​ byte short char int long float double

​ 1 2 2 4 8 4 8 （所占字节数）

低级向高级变量赋值时系统会自动完成数据类型的转换。

高级向低级变量强制类型转换时可能导致精度的损失。

获取输入的例子：

import java.util.Scanner;

public class Get_input {
    
    public static void main(Strings args[]) {

        Scanner reader = new Scanner(System.in);

        System.out.println("请分别输入一个整数、一个小数和一个字符：");

        int x = reader.nextInt();

        double y = reader.nextDouble();
        
        char z = reader.nextChar();
        
        System.out.printf("\n获取到您的输入分别为：%d  %f  %c", x, y, z);
    }
 
}

类与对象

类时面向对象语言中最重要的一种数据类型，可用来声明变量，用类声明的变量也被称为对象。

构造方法是类中的一种特殊方法，当程序用类创建对象时需要使用它的构造方法。类中的构造方法的名字需和所在类的类名完全相同，而且没有类型。允许一个类中编写多个构造方法，但必须保证它们的参数不同（参数个数或参数类型不同）。若类定义里定义了一个或多个构造方法，那么系统不提供默认的构造方法。但若类中没有编写构造方法，则系统默认该类仅有一个无参数、无方法体的构造方法。

没有实体的对象称为空对象，空对象无法使用。若使用了空对象，运行时会出现异常（NullPointerException）。由于对象是动态的分配实体，所以Java编译器对空对象不做检查。因此在编写程序时要避免使用空对象。

垃圾回收机制：一个类声明的两个对象如果具有相同的引用，那么它们就具有完全相同的实体，Java的垃圾回收机制会周期地检测某个实体是否已不再被任何对象拥有（引用），如果发现有这样的实体，便会释放该实体所占有的内存。

引用类型参数的传值传递的是“引用“，与原变量指向相同的实体，其中一个实体发生变化也会影响另一个。

实例变量/方法是所有实例所独有的，而使用static声明的类变量/方法是所有实例所共享的。实例变量/方法通过实例访问而无法用类名访问。

Java中存在两种多态，重载（Overload）与重写（Override）。方法重载是指一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同（参数个数或参数类型）。重写是个与继承有关的多态。

this关键字表示某个对象，可以在实例方法和构造方法中，但不能出现在类方法中。在构造方法中时，代表使用该构造方法创建的对象。 在实例方法中时，代表正在调用该方法的当前对象。

包是Java语言中有效地管理类的一个机制。不同Java源文件中可能出现名字相同的类，如果想区分这些类，就需要使用包名。包名能有效地区分同名的类。可通过package来声明包语句。

如果程序使用了包语句package a.b;，那么存储文件的目录结构中必须包含如下的结构…\a\b。

使用import可以引入包中的类。Java为我们提供了大约130个包。例：java.lang提供了核心的基础类（默认自动引入），java.util提供了实用工具类。

访问权限：

访问权限	修饰符	类内	同包	不同包子类	不同包非子类
私有	private	√	×	×	×
友好	default	√	√	×	×
受保护	protected	√	√	√	×
公共	public	√	√	√	√

可变参数是指在声明方法时不给出参数列表中从某项至最后一项参数的名字和个数，但这些参数的类型必须相同。可用”…“来表示若干个参数，这些参数的类型相同，且最后一个参数也必须是参数列表中最后一个参数。例：public void function(int … x)，x即为参数列表中可变参数的”参数代表“，可用x[0]~x[n]来访问x代表的第0个至第n个参数。

子类与继承

继承是一种由已有类创建新类的机制。由继承得到的类称为子类，被继承的类称为父类（超类）。Java不支持多重继承，即子类只能有一个父类。

子类和父类在同一个包中的继承：子类继承父类中不是private访问权限的所有成员变量或方法。且继承得到的访问权限不会改变。

子类和父类不在同一个包中的继承：子类只继承父类中protected和public访问权限的所有成员变量或方法。

成员变量的隐藏：若子类声明的成员变量的名字与父类继承来的成员变量的名字相同（类型可不同），则此时子类就会隐藏掉继承来的同名成员变量。但子类对象仍然可用通过调用父类继承的方法操作隐藏的成员变量。

方法重写（方法覆盖）：子类可用通过方法重写来隐藏所继承的实例方法。需保证方法的名字、参数个数、参数类型和父类实例方法完全相同。重写方法既可以操作继承的成员变量、调用继承的方法，也可以操作子类新声明的成员变量、调用新定义的其他方法，但无法操作被子类隐藏的父类成员变量或方法。

如果子类想使用被隐藏的实例方法或成员变量，必须使用关键字super。一旦子类隐藏了继承的成员变量或方法，那么这些被隐藏的成员变量或方法将归关键字super所拥有，子类想调用也需要使用super关键字。例：super.x，super.function()。

当子类的构造方法创建一个子类对象时，没有明显的写出super关键字来调用父类的哪个构造方法，默认有super(); 调用的是父类无参数的构造方法，所有在父类中应当包括一个无参数的构造方法，以防省略super时出现错误。

final关键字：修饰类则该类不能有子类，无法被继承。修饰成员变量则该变量是常量，无法被修改。修饰方法则该方法不允许被子类重写。

对象的上转型对象：上转型对象实体由子类负责创建，但声明为父类，则会失去子类的新增的变量和方法。例：假设A的子类是B，则A a = new B(); 创建了上转型对象a。

上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法和重写的实例方法。

上转型对象在调用某些多个子类都重写的方法时就体现出了多态。例：

class 动物 {
    void cry() {}
}
class 猫 extend 动物 {
    void cry() {
        System.out.println("喵喵喵~");
	}
}
class 狗 extend 动物 {
    void cry() {
        System.out.printlb("汪汪汪~");
    }
}

public class Test {
    public static void main(String args[]) {
        动物 animal;  //声明父类对象作为上转型对象
        animal = new 猫();  //上转型为子类中的猫
        animal.cry();  //此时调用animal.cry()输出为 喵喵喵~
        animal = new 狗();  //上转型为子类中的狗
        animal.cry();  //此时同样调用animal.cry()输出为 汪汪汪~
	}
}

abstract（抽象）关键字：abstract修饰的类为抽象类，不能用来实例化创建对象（不能new）。abstract修饰的方法为抽象方法，只能声明，不能定义方法体，自然也不能使用final来修饰抽象方法。

面向抽象编程， abstract修饰的类或方法只关心操作，不关心这些操作具体的实现，留给子类完成细节的设计。

接口与实现

implements关键字：类可以通过implements声明自己实现一个或多个接口，如果一个非抽象类实现了某个接口，那么这个类必须重写接口的所有方法，且由于接口中给出的方法一定是public abstract方法，所以非抽象类在实现接口方法时应去掉abstract修饰，并保证访问权限为public。

接口只关心操作，并不关心操作的具体实现，接口中只有abstract方法。不同的类可以实现相同的接口，同一个类也可以实现多个接口。

接口回调：可以把实现某一接口的类创建的对象的引用赋值给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口方法。例：

interface Cry {
    void 叫();
}
class 猫 implements Cry {
    public void 叫() {
        System.out.println("喵喵喵~");
    }
}
class 狗 implements Cry {
    public void 叫() {
        System.out.println("汪汪汪~");
    }
}

public class Test {
    public static void main(String args[]) {
        Cry crying;  //创建接口变量
        crying = new 猫();  //接口变量中存放对象的引用
        crying.叫();  //接口回调，输出为 喵喵喵~
        crying = new 狗();  //接口实现多态
        crying.叫();  //接口回调，输出为 汪汪汪~
    }
}

abstract类与接口的比较：

​ ①abstract类和接口都可以有abstract方法。

​ ②abstract类中可以有非abstract方法，接口只能有abstract修饰的方法。

​ ③abstract类中可以有常量也可以有变量，接口中只能有常量，不能有变量。

内部类与异常类

Java支持在一个类中声明另一个类，这样的类被称为内部类，而包含内部类的类被称为内部类外嵌类。内部类仅供它的外嵌类使用，其他类不能使用内部变量声明对象。例：

public class A {  //外嵌类A
	...
	class B {  //内部类B
		...
	}
	...
}

匿名类：假如没有显示地声明一个类的子类，而又想用子类创建一个对象，Java允许我们直接使用一个类的子类的类体来创建一个子类对象，即除了使用父类的构造方法外，还可以通过一个子类去掉类声明的类体来创建子类对象，称作匿名类。匿名类算是一个子类，但是由于无名可用，所以不可能用匿名类来声明对象，只能用来创建一个匿名类对象。例：

new A() {
  ...  //匿名类的类体  
};  //创建了一个A的子类（匿名类）

异常类：异常就是程序运行时可能出现的一些错误，异常处理将会改变程序的控制流程，让程序有机会对错误做处理。Java的异常出现在方法的调用过程中，即在方法调用过程中抛出异常对象，终止当前方法的继续执行，同时导致程序运行出现异常，并等待处理。

try-catch-finally语句：

try {
    ...  //包含可能发生异常的语句
}
catch(Exception e) {
    System.out.println(e);  //输出有关异常的信息
}
finally {
    ...  //无论在try部分是否发生过异常，finally子语句都会执行
}

自定义异常类：在编写程序时可扩展Exception类来定义自己的异常类，然后根据程序的需要来规定哪些方法产生这样的异常。方法在声明时可以通过throw关键字来声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操作，即用相应的异常类创建对象，并使用throw关键字抛出异常对象，导致该方法结束执行。程序必须在try-catch块语句中调用能抛出异常的方法，其中catch的作用就是捕获throw抛出的异常对象。例：

class MyRangeException extends Exception {  //扩展Exception
    String error_message;  //声明错误信息
    public MyRangeException(double x) {  //接收传入的异常值x
        error_message = "范围错误：输入的数" + x + "不在0~100的范围内！";  //定义错误信息
    }
    public String ErrorMess() {  //声明用于返回错误信息的函数
        return error_message;  //返回错误信息
    }
}

public class Test {
    void test_num(double x) throws MyRangeException {  //throws关键字声明要产生的异常
        if(x < 0 || x > 100) {  //判断输入的数x是否在0~100范围内
            throw new MyRangeException(x);  //若不在范围内则抛出自定义的范围异常
        }
        else {
            System.out.println("输入的数" + x + "满足范围约束。");
        }
    }
  	public static void main(String args[]) {
        try {
    		test_num(1.23);  //输出为 输入的数1.23满足范围约束。
        	test_num(123);  //捕获到异常，输出为 输入的数123不在0~100的范围内！
            test_num(12.3);  //由于前面出现了异常导致该条语句没机会执行
        }
        catch(MyRangeException e) {
            System.out.println(e.ErrorMess);  //异常处理，输出异常信息
        }
    }
}

断言：断言语句在调试代码阶段非常有用，断言语句一般用于程序不准备通过捕获异常来处理的错误。

使用关键字assert声明一条断言语句，格式为assert booleanExpression:messageException

例：

assert 0<x<100:"输入的数不在0~范围内";

（若有纰漏 尽请指出）