2021-06-27

javase 

1、什么是JDK，JRE

JDK( J ava D evelopment K it Java 开发工具包 )

JDK 是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了 JRE。所以安装了 JDK ，就不用在单独安装 JRE 了。

其中的开发工具：编译工具 (javac.exe) 打包工具 (jar.exe) 等。

JRE( J ava R untime E nvironment Java 运行环境 )

包括 Java 虚拟机 (JVM J ava V irtual M achine) 和 Java 程序所需的核心类库等， 如果想要 运行 一个开发好的 Java 程序，计算机中只需要安装 JRE 即可。

2、基本数据类型

基本数据类型包括byte、int、char、long、float、double、boolean和short。

3、编码

ASCII 码：上个世纪 60 年代，美国制定了一套字符编码，对英语字符与二进制位之间的

关系，做了统一规定。这被称为 ASCII 码。

Unicode ： 一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一

无二的编码，使用 Unicode 没有乱码的问题。

UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。

UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据

不同的符号而变化字节长度。

4、四种访问权限修饰符

符 public 、 protected 、 ( 缺省 ) 、 private

5、多态

对象的多态 — 在 Java 中 , 子类 的对象可以替代 父类 的对象使用。

一个变量只能有一种确定的数据类型

一个引用类型变量可能指向 ( 引用 ) 多种不同类型的对象

Person p = new Student();

Object o = new Person(); //Object 类型的变量 o ，指向 Person 类型的对象

o = new Student(); //Object 类型的变量 o ，指向 Student 类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向 上转型 (upcasting)。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类 对象，那么该变量就 不能 再访问子类中添加的属性和方法。

Student m = new Student();

m.school = “pku”;

// 合法 ,Student 类有 school 成员变量

Person e = new Student();

e.school = “pku”;

// 非法 ,Person 类没有 school 成员变量

属性是在编译时确定的，编译时 e 为 Person 类型，没有 school 成员变量，因而编 译错误。

x instanceof A ：检验 x 是否为类 A 的对象，返回值为 boolean 型。

要求 x 所属的类与类 A 必须是子类和父类的关系，否则编译错误。

如果 x 属于类 A 的子类 B ， x instanceof A 值也为 true 。

public class Person extends Object {…}

public class Student extends Person {…}

public class Graduate extends Person {…}

-------------------------------------------------------------------

public void method1(Person e) {

if (e instanceof Person)

// 处理 Person 类及其子类对象

if (e instanceof Student)

// 处理 Student 类及其子类对象

if (e instanceof Graduate)

// 处理 Graduate 类及其子类对象

}

从子类到父类的类型转换可以自动进行

从父类到子类的类型转换必须通过造型 ( 强制类型转换 ) 实现

无继承关系的引用类型间的转换是非法的

在造型前可以使用 instanceof 操作符测试一个对象的类型

6、==和equals的区别

1

== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型

就是比较内存地址

2

equals 的话，它是属于 java.lang.Object 类里面的方法，如果该方法没有被重写过默认也

是 ==; 我们可以看到 String 等类的 equals 方法是被重写过的，而且 String 类在日常开发中

用的比较多，久而久之，形成了 equals 是比较值的错误观点。

3

具体要看自定义类里有没有重写 Object 的 equals 方法来判断。

4

通常情况下，重写 equals 方法，会比较类中的相应属性是否都相等。

7、基本类型、包装类与String类间的转换

    public static void main(String[] args) {
        String i = "11";
        Integer i1 = Integer.parseInt(i); //string转包装类
        int i2 = i1; //自动拆装箱
        System.out.println(i2);
    }

8、关键字：static

在 Java 类中，可用 static 修饰 属性、方法 、 代码块、内部类。

随着类的加载而加载

优先于对象存在

修饰的成员，被所有对象所共享

访问权限允许时，可不创建对象，直接被类调用

没有对象的实例时，可以用 类名 . 方法名 () 的形式访问由 static 修饰的类方法。

在 static 方法内部只能访问类的 static 修饰的属性或方法，不能访问类的非 static 的结构。

因为不需要实例就可以访问 static 方法，因此 static 方法内部不能有 this 。 ( 也 不能有 super ? YES!

static 修饰的方法不能被重写

9、单例 (Singleton)设计模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类 只能存在一个对象实例 ，并且该类只提供一个取得其对象实例的方法。

首先必须将类的 构 造器的访问权限设置为private ， 调用该类的某个静态方法 以返回类内部创建的对象， 指向类内部产生的 该类对象的变量也必须定义成静态的 。

饿汉式

class Singleton {
// 1.私有化构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single = new Singleton();
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
return single; } }

懒汉式

class Singleton {
// 1.私有化构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single;
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
if(single == null) {
single = new Singleton();
}
return single; } }

网站的计数器 ，一般也是单例模式实现，否则难以同步。

应用程序的日志应用 ，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

数据库连接池 的设计一般也是采用单例模式，因为数据库连接是一种数据库 资源。

项目中， 读取配置文件的类 ，一般也只有一个对象。没有必要每次使用配置

文件数据，都生成一个对象去读取。

Application 也是单例的典型应用

Windows 的 Task Manager ( 任务管理器 ) 就是很典型的单例模式

Windows 的 Recycle Bin ( 回收站 ) 也是典型的单例应用。在整个系统运行过程

中，回收站一直维护着仅有的一个实例。

10、main函数

由于 Java 虚拟机需要调用类的 main() 方法，所以该方法的访问权限必须是 public，又因为 Java 虚拟机在执行 main() 方法时不必创建对象，所以该方法必须 是static 的，该方法接收一个 String 类型的数组参数，该数组中保存执行 Java 命令 时传递给所运行的类的参数。

又因为 main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创 建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

11、finally、final、finaize区别

final：final可以修饰类、方法、变量，分别有不同的意义，修饰类时该类不能被继承，修饰方法时，该方法在被继承后不能被重写(override)，修饰变量时该变量值不可被改变。

在 Java 中声明 类、变量和方法 时，可使用关键字 final 来修饰 , 表示“最终的”。

final 标记的类不能被继承。 提高安全性，提高程序的可读性。

String 类、 System 类、 StringBuffer 类

final 标记的方法不能被子类重写。

比如： Object 类中的 getClass() 。

final 标记的变量 ( 成员变量或局部变量 ) 即称为常量。 名称大写，且只能被赋值一次 。

final 标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋

值，然后才能使用。

final double MY_PI = 3.14;

finally：finally是处理异常时经常使用的关键字，形如try-catch-finally或try-finally，finally里的代码块总会执行。
finaize：finaize是java.lang.Object里的一个方法，目的是保证对象在被垃圾收集前完成特定资源的回收，当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

12、内部类

定义：Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类.

成员内部类（静态、非静态 ） vs 局部内部类(方法内、代码块内、构造器内)

一方面，作为外部类的成员：
 *             >调用外部类的结构
 *             >可以被static修饰
 *             >可以被4种不同的权限修饰
 * 
另一方面，作为一个类：
 *             > 类内可以定义属性、方法、构造器等
 *             > 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
 *             > 可以被abstract修饰

//创建静态的Dog内部类的实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();

//创建非静态的Bird内部类的实例(非静态的成员内部类):
//Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();

* 类的内部成员之五：内部类
 * 1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
 * 
 * 2.内部类的分类：成员内部类（静态、非静态）  vs 局部内部类(方法内、代码块内、构造器内)
 * 
 * 3.成员内部类：
 * 		一方面，作为外部类的成员：
 * 			>调用外部类的结构
 * 			>可以被static修饰
 * 			>可以被4种不同的权限修饰
 * 
 * 		另一方面，作为一个类：
 * 			> 类内可以定义属性、方法、构造器等
 * 			> 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
 * 			> 可以被abstract修饰
 * 
 * 
 * 4.关注如下的3个问题
 *   4.1 如何实例化成员内部类的对象
 *   4.2 如何在成员内部类中区分调用外部类的结构
 *   4.3 开发中局部内部类的使用  见《InnerClassTest1.java》
 * 
 */
public class InnerClassTest {
	public static void main(String[] args) {
		
		//创建Dog实例(静态的成员内部类):
		Person.Dog dog = new Person.Dog();
		dog.show();
		//创建Bird实例(非静态的成员内部类):
//		Person.Bird bird = new Person.Bird();//错误的
		Person p = new Person();
		Person.Bird bird = p.new Bird();
		bird.sing();
		
		System.out.println();
		
		bird.display("黄鹂");
		
	}
}


class Person{
	
	String name = "小明";
	int age;
	
	public void eat(){
		System.out.println("人：吃饭");
	}
	
	
	//静态成员内部类
	static class Dog{
		String name;
		int age;
		
		public void show(){
			System.out.println("卡拉是条狗");
//			eat();
		}
		
	}
	//非静态成员内部类
	class Bird{
		String name = "杜鹃";
		
		public Bird(){
			
		}
		
		public void sing(){
			System.out.println("我是一只小小鸟");
			Person.this.eat();//调用外部类的非静态属性
			eat();
			System.out.println(age);
		}
		
		public void display(String name){
			System.out.println(name);//方法的形参
			System.out.println(this.name);//内部类的属性
			System.out.println(Person.this.name);//外部类的属性
		}
	}
	
	
	public void method(){
		//局部内部类
		class AA{
			
		}
	}
	
	{
		//局部内部类
		class BB{
			
		}
	}
	
	public Person(){
		//局部内部类
		class CC{
			
		}
	}
	
}

13、异常

常用的异常对象处理的方式： ① String  getMessage()    ② printStackTrace()

e.getMessage()  e.printStackTrace()

体会1：使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
 体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常，我们说一定要考虑异常的处理。

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

try-catch-finally:真正的将异常给处理掉了。
throws的方式只是将异常抛给了方法的调用者。并没真正将异常处理掉。

 *  5.1 如果父类中被重写的方法没throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中异常，必须使用try-catch-finally方式处理。
 *  5.2 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。