[修饰符列表] abstract class 类名{
					类体;
				}

public abstract void doSome();//没有方法体，以分号结尾。

[修饰符列表] interface 接口名{}

class D implements A,B,C{//实现多个接口，类似于多继承
	// 实现A接口的m1()
	public void m1(){
}

class Test01{
    //该类在类的内部，所以称为内部类
 	//静态变量
	static String country;
 由于前面有static，所以称为“静态内部类”：
	static class Inner1{
	}
    
	// 实例变量
	int age;
没有static叫做实例内部类：
	class Inner2{
	}

	// 方法
	public void doSome(){
		// 局部变量
		int i = 100;
 局部内部类：
		class Inner3{
		}
	}

class Test01{
	public static void main(String[] args){
使用匿名内部类
	mm.mySum(new Compute(){
			public int sum(int a, int b){
				return a + b;
			}
		}, 200, 300);
未使用匿名内部类：
	mm.mySum(new ComputeImpl(), 100, 200);
	}
}

// 负责计算的接口
interface Compute{ 
	
	// 抽象方法
	int sum(int a, int b);
}

// Compute接口的实现类
class ComputeImpl implements Compute{
	// 对方法的实现
	public int sum(int a, int b){
		return a + b;
	}
}

int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;

int[] array = {100, 2100, 300, 55};

int[] array = new int[5]; // 这里的5表示数组的元素个数。
                            // 初始化一个5个长度的int类型数组，每个元素默认值0
String[] names = new String[6]; // 初始化6个长度的String类型数组，每个元素默认值null。

package com.javase.array;
/*
模拟一个系统，假设这个系统要使用，必须输入用户名和密码。
 */
public class ArrayTest06 {
    // 用户名和密码输入到String[] args数组当中。
    public static void main(String[] args) {
        if(args.length != 2){
            System.out.println("使用该系统时请输入程序参数，参数中包括用户名和密码信息，例如：zhangsan 123");
            return;
        }
        // 程序执行到此处说明用户确实提供了用户名和密码。
        // 接下来判断用户名和密码是否正确。
        // 取出用户名
        String username = args[0];
        // 取出密码
        String password = args[1];
        // 假设用户名是admin，密码是123的时候表示登录成功。其它一律失败。
        // 判断两个字符串是否相等，需要使用equals方法。
        //if(username.equals("admin") && password.equals("123")){
        // 采用以下编码风格，即使username和password都是null，也不会出现空指针异常。
        if("admin".equals(username) && "123".equals(password)){
            System.out.println("登录成功，欢迎[" + username + "]回来");
            System.out.println("您可以继续使用该系统....");
        }else{
            System.out.println("验证失败，用户名不存在或者密码错误！");
        }
    }
}

System.arraycopy(5个参数);

int[][] array = {{1,1,1},{2,3,4,5},{0,0,0,0},{2,3,4,5},{2,3,4,5},{2,3,4,5},{2,3,4,5}};

int[][] array = new int[3][4];

// 排序
        Arrays.sort(arr);
 // 二分法查找（建立在排序基础之上。）
		int index = Arrays.binarySearch(arr, 5);

public class StringTest03 {
    public static void main(String[] args) {
        /*
        一共3个对象：
            方法区字符串常量池中有1个："hello"
            堆内存当中有两个String对象。
            一共3个。
         */
        String s1 = new String("hello");
        String s2 = new String("hello");
    }
}

public class StringTest02 {
    public static void main(String[] args) {
        String s1 = "hello";
        // "hello"是存储在方法区的字符串常量池当中
        // 所以这个"hello"不会新建。（因为对象已经存在了）
        String s2 = "hello";
        // == 双等号比较变量中保存的内存地址
        System.out.println(s1 == s2); // true
        String x = new String("xyz");
        String y = new String("xyz");
        System.out.println(x == y); //false
        // 通过这个案例的学习，我们知道了，字符串对象之间的比较不能使用“==”
        // String类已经重写了equals方法，以下的equals方法调用的是String重写之后的equals方法。
        System.out.println(x.equals(y)); // true
    }
}

第一个：String s = new String("");
	String s6 = new String("helloworld!");
第二个：String s = ""; 最常用
    String s1 =  "hello world!";
第三个：String s = new String(char数组);
    // 将char数组全部转换成字符串
    char[] chars = {'我','是','中','国','人'};
    String s4 = new String(chars);
    System.out.println(s4);
第四个：String s = new String(char数组,起始下标,长度);
    // 将char数组的一部分转换成字符串
   	String s5 = new String(chars, 2, 3);
第五个：String s = new String(byte数组);
 	byte[] bytes = {97, 98, 99}; // 97是a，98是b，99是c
    String s2 = new String(bytes);
    // 输出字符串对象的话，输出的不是对象的内存地址，而是字符串本身。
   	System.out.println(s2.toString()); //abc
  	System.out.println(s2); //abc
第六个：String s = new String(byte数组,起始下标,长度)
    // 将byte数组中的一部分转换成字符串。
    String s3 = new String(bytes, 1, 2);
    System.out.println(s3); // bc

// 字符串之间比较大小需要使用compareTo方法。
       int result = "abc".compareTo("abc");
       System.out.println(result); //0（等于0） 前后一致  10 - 10 = 0
 
       int result2 = "abcd".compareTo("abce");
       System.out.println(result2); //-1（小于0） 前小后大 8 - 9 = -1
 
       int result3 = "abce".compareTo("abcd");
       System.out.println(result3); // 1（大于0） 前大后小 9 - 8 = 1
 

// 判断前面的字符串中是否包含后面的子字符串。
        System.out.println("HelloWorld.java".contains(".java")); // true
        System.out.println("http://www.baidu.com".contains("https://")); // false

// 判断当前字符串是否以某个子字符串结尾。
        System.out.println("test.txt".endsWith(".java")); // false
        System.out.println("test.txt".endsWith(".txt")); // true
        System.out.println("fdsajklfhdkjlsahfjkdsahjklfdss".endsWith("ss")); // true

// 比较两个字符串必须使用equals方法，不能使用“==”
        // equals只能看出相等不相等。
        // compareTo方法可以看出是否相等，并且同时还可以看出谁大谁小。
        System.out.println("abc".equals("abc")); // true

// 判断两个字符串是否相等，并且同时忽略大小写。
        System.out.println("ABc".equalsIgnoreCase("abC")); // true

// 将字符串对象转换成字节数组
        byte[] bytes = "abcdef".getBytes();
        for(int i = 0; i < bytes.length; i++){
            System.out.println(bytes[i]);
        }

// 判断某个子字符串在当前字符串中第一次出现处的索引（下标）。
        System.out.println("oraclejavac++.netc#phppythonjavaoraclec++".indexOf("java")); //6

// 判断某个字符串是否为“空字符串”。底层源代码调用的应该是字符串的length()方法。
        //String s = "";
        String s = "a";
        System.out.println(s.isEmpty());

// 面试题：判断数组长度和判断字符串长度不一样
// 判断数组长度是length属性，判断字符串长度是length()方法。
System.out.println("abc".length()); // 3

// 判断某个子字符串在当前字符串中最后一次出现的索引（下标）
    System.out.println("oraclejavac++javac#phpjavapython".lastIndexOf("java")); //22

// 替换。
       // String的父接口就是：CharSequence
       String newString = "http://www.baidu.com".replace("http://", "https://");
       System.out.println(newString); //https://www.baidu.com
       // 把以下字符串中的“=”替换成“:”
       String newString2 = "name=zhangsan&password=123&age=20".replace("=", ":");
       System.out.println(newString2); //name:zhangsan&password:123&age:20

// 拆分字符串
        String[] ymd = "1980-10-11".split("-"); //"1980-10-11"以"-"分隔符进行拆分。
        for(int i = 0; i < ymd.length; i++){
            System.out.println(ymd[i]);
        }
        String param = "name=zhangsan&password=123&age=20";
        String[] params = param.split("&");
        for(int i = 0; i <params.length; i++){
            System.out.println(params[i]);
            // 可以继续向下拆分，可以通过“=”拆分。
        }

// 判断某个字符串是否以某个子字符串开始。
        System.out.println("http://www.baidu.com".startsWith("http")); // true
        System.out.println("http://www.baidu.com".startsWith("https")); // false

// 截取字符串
       System.out.println("http://www.baidu.com".substring(7)); //www.baidu.com

// beginIndex起始位置（包括）
// endIndex结束位置（不包括）
        System.out.println("http://www.baidu.com".substring(7, 10)); //www

// 将字符串转换成char数组
       char[] chars = "我是中国人".toCharArray();
       for(int i = 0; i < chars.length; i++){
           System.out.println(chars[i]);
       }

// 转换为小写。
       System.out.println("ABCDefKXyz".toLowerCase());

//转换为大写。
System.out.println("ABCDefKXyz".toUpperCase());

// 去除字符串前后空白
        System.out.println("           hello      world             ".trim());

// 作用：将“非字符串”转换成“字符串”
        String s1 = String.valueOf(true);
        String s1 = String.valueOf(100);
        String s1 = String.valueOf(3.14);
		String s1 = String.valueOf(new Customer());
//本质上System.out.println()这个方法在输出任何数据的时候都是先调用valueOf转换成字符串，再输出。
		System.out.println(s1);// Customer类中没有重写toString()方法之前是对象内存地址
		

java.lang.StringBuffer
java.lang.StringBuilder

public class StringBufferTest02 {
    public static void main(String[] args) {
        // 创建一个初始化容量为16个byte[] 数组。（字符串缓冲区对象）
        StringBuffer stringBuffer = new StringBuffer();
        // 拼接字符串，以后拼接字符串统一调用 append()方法。
        // append是追加的意思。
        stringBuffer.append("a");
        stringBuffer.append(3.14);
        stringBuffer.append(true);
        // append方法底层在进行追加的时候，如果byte数组满了，会自动扩容。
        // 指定初始化容量的StringBuffer对象（字符串缓冲区对象）
        StringBuffer sb = new StringBuffer(100);
        sb.append("hello");
        System.out.println(sb);
    }
}

基本数据类型             包装类型
   -------------------------------------
   byte                    java.lang.Byte（父类Number）
   short                   java.lang.Short（父类Number）
   int                     java.lang.Integer（父类Number）
   long                    java.lang.Long（父类Number）
   float                   java.lang.Float（父类Number）
   double                  java.lang.Double（父类Number）
   boolean                 java.lang.Boolean（父类Object）
   char                    java.lang.Character（父类Object）

byte byteValue() 以 byte 形式返回指定的数值。
abstract  double doubleValue()以 double 形式返回指定的数值。
abstract  float floatValue()以 float 形式返回指定的数值。
abstract  int intValue()以 int 形式返回指定的数值。
abstract  long longValue()以 long 形式返回指定的数值。
short shortValue()以 short 形式返回指定的数值。

/*
这个题目是Integer非常重要的面试题。
 */
public class IntegerTest06 {
    public static void main(String[] args) {
        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b); //false
        /*
        java中为了提高程序的执行效率，将[-128到127]之间所有的包装对象提前创建好，
        放到了方法区的“整数型常量池”中，目的是只要用这个区间的数据不需要再new，
        直接从整数型常量池当中取出来。
        原理：x变量中保存的对象的内存地址和y变量中保存的对象的内存地址是一样的。
         */
        Integer x = 127;
        Integer y = 127;
        // == 永远判断的都是两个对象的内存地址是否相同。
        System.out.println(x == y); //true
    }
}

public class IntegerTest07 {
    public static void main(String[] args) {
        // 手动装箱
        Integer x = new Integer(1000);
        // 手动拆箱。
        int y = x.intValue();
        System.out.println(y);
        Integer a = new Integer("123");
        // 编译的时候没问题，一切符合java语法，运行时会不会出问题呢？

// java.lang.NumberFormatException
Integer a = new Integer("中文");

// 静态方法，传参String，返回int
//网页上文本框中输入的100实际上是"100"字符串。后台数据库中要求存储100数字，此时java程序需要将"100"转换成100数字。
        int retValue = Integer.parseInt("123"); // String -转换-> int
        int retValue = Integer.parseInt("中文"); // NumberFormatException
        System.out.println(retValue + 100);

// 以下类推
        double retValue2 = Double.parseDouble("3.14");
        System.out.println(retValue2 + 1); //4.140000000000001（精度问题）

        float retValue3 = Float.parseFloat("1.0");
        System.out.println(retValue3 + 1); //2.0

//static String toBinaryString(int i)静态的：将十进制转换成二进制字符串。
        String binaryString = Integer.toBinaryString(3);
        System.out.println(binaryString); //"11" 二进制字符串

//static String toHexString(int i)静态的：将十进制转换成十六进制字符串。
        hexString = Integer.toHexString(17);
        System.out.println(hexString); // "11"

//static String toOctalString(int i)静态的：将十进制转换成八进制字符串。
        String octalString = Integer.toOctalString(8);
        System.out.println(octalString); // "10"

        System.out.println(new Object()); //java.lang.Object@6e8cf4c6

//valueOf方法
        //static Integer valueOf(int i)
        // 静态的：int-->Integer
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);

        // static Integer valueOf(String s)
        // 静态的：String-->Integer
        Integer i2 = Integer.valueOf("100");
        System.out.println(i2);
    }
}

public class IntegerTest08 {
    public static void main(String[] args) {

        // String --> int
        int i1 = Integer.parseInt("100"); // i1是100数字
        System.out.println(i1 + 1); // 101

        // int --> String
        String s2 = i1 + ""; // "100"字符串
        System.out.println(s2 + 1); // "1001"

        // int --> Integer
        // 自动装箱
        Integer x = 1000;

        // Integer --> int
        // 自动拆箱
        int y = x;

        // String --> Integer
        Integer k = Integer.valueOf("123");

        // Integer --> String
        String e = String.valueOf(k);
    }
}

import java.util.Date;
import java.text.SimpleDateFormat;

public class DateTest01 {
    public static void main(String[] args) throws Exception {
        // 获取系统当前时间（精确到毫秒的系统当前时间）
        // 直接调用无参数构造方法就行。
        Date nowTime = new Date();

        // java.util.Date类的toString()方法已经被重写了。
        // 输出的应该不是一个对象的内存地址，应该是一个日期字符串。
        //System.out.println(nowTime); //Thu Mar 05 10:51:06 CST 2020

      // 将日期类型Date，按照指定的格式进行转换：Date --转换成具有一定格式的日期字符串-->String
//SimpleDateFormat是java.text包下的。专门负责日期格式化的。
      /*
      yyyy 年(年是4位)
      MM 月（月是2位）
      dd 日
      HH 时
      mm 分
      ss 秒
      SSS 毫秒（毫秒3位，最高999。1000毫秒代表1秒）
      注意：在日期格式中，除了y M d H m s S这些字符不能随便写之外，剩下的符号格式自己随意组织。
       */
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
      //SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
      //SimpleDateFormat sdf = new SimpleDateFormat("yy/MM/dd HH:mm:ss");

      String nowTimeStr = sdf.format(nowTime);
      System.out.println(nowTimeStr);

        // String --> Date
        String time = "2008-08-08 08:08:08 888";
        //SimpleDateFormat sdf2 = new SimpleDateFormat("格式不能随便写，要和日期字符串格式相同");
        // 注意：字符串的日期格式和SimpleDateFormat对象指定的日期格式要一致。不然会出现异常：java.text.ParseException
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        Date dateTime = sdf2.parse(time);
        System.out.println(dateTime); //Fri Aug 08 08:08:08 CST 2008
    }
}

public class DateTest02 {
    public static void main(String[] args) {
        // 获取自1970年1月1日 00:00:00 000到当前系统时间的总毫秒数。
        long nowTimeMillis = System.currentTimeMillis();
        System.out.println(nowTimeMillis); //1583377912981

        // 统计一个方法耗时
        // 在调用目标方法之前记录一个毫秒数
        long begin = System.currentTimeMillis();
        print();
        // 在执行完目标方法之后记录一个毫秒数
        long end = System.currentTimeMillis();
        System.out.println("耗费时长"+(end - begin)+"毫秒");
    }
    // 需求：统计一个方法执行所耗费的时长
    public static void print(){
        for(int i = 0; i < 1000000000; i++){
            System.out.println("i = " + i);
        }
    }
}

import java.text.DecimalFormat;

public class DecimalFormatTest01 {
    public static void main(String[] args) {
        // java.text.DecimalFormat专门负责数字格式化的。
        //DecimalFormat df = new DecimalFormat("数字格式");
        /*
        数字格式有哪些？
            # 代表任意数字
            , 代表千分位
            . 代表小数点
            0 代表不够时补0
            ###,###.##
                表示：加入千分位，保留2个小数。
         */
        DecimalFormat df = new DecimalFormat("###,###.##");
        //String s = df.format(1234.56);
        String s = df.format(1234.561232);
        System.out.println(s); // "1,234.56"
        
        DecimalFormat df2 = new DecimalFormat("###,###.0000"); //保留4个小数位，不够补上0
        String s2 = df2.format(1234.56);
        System.out.println(s2); // "1,234.5600"

    }
}

public class BigDecimalTest01 {
    public static void main(String[] args) {
        // 这个100不是普通的100，是精度极高的100
        BigDecimal v1 = new BigDecimal(100);
        // 精度极高的200
        BigDecimal v2 = new BigDecimal(200);
        // 求和
        // v1 + v2; // 这样不行，v1和v2都是引用，不能直接使用+求和。
        BigDecimal v3 = v1.add(v2); // 调用方法求和。
        System.out.println(v3); //300
        BigDecimal v4 = v2.divide(v1);
        System.out.println(v4); // 2
    }
}

import java.util.Random;

public class RandomTest01 {
    public static void main(String[] args) {
        // 创建随机数对象
        Random random = new Random();

        // 随机产生一个int类型取值范围内的数字。
        int num1 = random.nextInt();

        System.out.println(num1);

        // 产生[0~100]之间的随机数。不能产生101。
        // nextInt翻译为：下一个int类型的数据是101，表示只能取到100.
        int num2 = random.nextInt(101); //不包括101
        System.out.println(num2);
    }
}

public class EnumTest02 {
    public static void main(String[] args) {
        Result r = divide(10, 2);
        System.out.println(r == Result.SUCCESS ? "计算成功" : "计算失败");
    }
    /**
     * 计算两个int类型数据的商。
     * @param a int数据
     * @param b int数据
     * @return Result.SUCCESS表示成功，Result.FAIL表示失败！
     */
    public static Result divide(int a, int b){
        try {
            int c = a / b;
            return Result.SUCCESS;
        } catch (Exception e){
            return Result.FAIL;
        }
    }
}
// 枚举：一枚一枚可以列举出来的，才建议使用枚举类型。
// 枚举编译之后也是生成class文件。
// 枚举也是一种引用数据类型。
// 枚举中的每一个值可以看做是常量。
enum Result{
    // SUCCESS 是枚举Result类型中的一个值
    // FAIL 是枚举Result类型中的一个值
    // 枚举中的每一个值，可以看做是“常量”
    SUCCESS, FAIL
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ExceptionTest06 {
    // 一般不建议在main方法上使用throws，因为这个异常如果真正的发生了，一定会抛给JVM。JVM只有终止。
    // 异常处理机制的作用就是增强程序的健壮性。怎么能做到，异常发生了也不影响程序的执行。所以
    // 一般main方法中的异常建议使用try..catch进行捕捉。main就不要继续上抛了。
    //public static void main(String[] args) throws FileNotFoundException {
    public static void main(String[] args) {
	// 100 / 0这是算术异常，这个异常是运行时异常，你在编译阶段，可以处理，也可以不处理。编译器不管。
    //System.out.println(100 / 0); // 不处理编译器也不管
        System.out.println("main begin");

        try {
            m1();
            // 以上代码出现异常，直接进入catch语句块中执行。
            System.out.println("hello world!");
        } catch (FileNotFoundException e){ // catch后面的好像一个方法的形参。
            // 这个分支中可以使用e引用，e引用保存的内存地址是那个new出来异常对象的内存地址。
            // catch是捕捉异常之后走的分支。
            // 在catch分支中干什么？处理异常。
            System.out.println("文件不存在，可能路径错误，也可能该文件被删除了！");
            System.out.println(e); //java.io.FileNotFoundException: D:\course\01-课\学习方法.txt (系统找不到指定的路径。)
        }
//---------------------------------------------------------------------------------------- 
        // try..catch把异常抓住之后，这里的代码会继续执行。
        System.out.println("main over");
    }

//----------------------------------------------------------------------------------------
    private static void m1() throws FileNotFoundException {
        System.out.println("m1 begin");
        m2();
        // 以上代码出异常，这里是无法执行的。
        System.out.println("m1 over");
    } 

//private static void m2() throws ClassCastException, FileNotFoundException{
private static void m2() throws FileNotFoundException {
    System.out.println("m2 begin");
    m3();
    // 以上如果出现异常，这里是无法执行的！
    System.out.println("m2 over");
}

    private static void m3() throws FileNotFoundException {
        // 调用SUN jdk中某个类的构造方法。
        // 创建一个输入流对象，该流指向一个文件。
        /*
        编译报错的原因是什么？
            第一：这里调用了一个构造方法：FileInputStream(String name)
            第二：这个构造方法的声明位置上有：throws FileNotFoundException
            第三：通过类的继承结构看到：FileNotFoundException父类是IOException，IOException的父类是			 Exception，
            最终得知，FileNotFoundException是编译时异常。
            错误原因？编译时异常要求程序员编写程序阶段必须对它进行处理，不处理编译器就报错。
         */
        new FileInputStream("D:\\course\\01-课\\学习方法.txt");
 		// 一个方法体当中的代码出现异常之后，如果上报的话，此方法结束。
        System.out.println("如果以上代码出异常，这里会执行吗??????????????????不会！！！");
    }
}

public class ExceptionTest07 {
    
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("D:\\curse\\02-JavaSE\\document\\JavaSE进阶讲义\\JavaSE进阶-01-面向对象.pdf");
            System.out.println("以上出现异常，这里无法执行！");
        } catch(FileNotFoundException e) {
            System.out.println("文件不存在！");
        }
//----------------------------------------------------------------------------------------      
        try {
            FileInputStream fis = new FileInputStream("D:\\curse\\02-JavaSE\\document\\JavaSE进阶讲义\\JavaSE进阶-01-面向对象.pdf");
        } catch(Exception e) { // 多态：Exception e = new FileNotFoundException();
            System.out.println("文件不存在！");
        }

          try {
            //创建输入流
            FileInputStream fis = new FileInputStream("D:\\curse\\02-JavaSE\\document\\JavaSE进阶讲义\\JavaSE进阶-01-面向对象.pdf");
            //读文件
            fis.read();
        } catch(FileNotFoundException e) {
            System.out.println("文件不存在！");
        } catch(IOException e){
            System.out.println("读文件报错了！");

//----------------------------------------------------------------------------------------
// 编译报错。
        try {
            //创建输入流
            FileInputStream fis = new FileInputStream("D:\\curse\\02-JavaSE\\document\\JavaSE进阶讲义\\JavaSE进阶-01-面向对象.pdf");
            //读文件
            fis.read();
        } catch(IOException e){
            System.out.println("读文件报错了！");
        } catch(FileNotFoundException e) {
            System.out.println("文件不存在！");
        }

//----------------------------------------------------------------------------------------
// JDK8的新特性
        try {
            //创建输入流
            FileInputStream fis = new FileInputStream("D:\\curse\\02-JavaSE\\document\\JavaSE进阶讲义\\JavaSE进阶-01-面向对象.pdf");
            // 进行数学运算
            System.out.println(100 / 0); // 这个异常是运行时异常，编写程序时可以处理，也可以不处理。
        } catch(FileNotFoundException | ArithmeticException | NullPointerException e) {
            System.out.println("文件不存在？数学异常？空指针异常？都有可能！");
        }
    }
}

public void test1() throws NullPointerExeption{
}

public void test1 (){
throw new RuntimeException ();
}

String msg = e.getMessage();
e.printStackTrace(); // 一般都是使用这个。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class ExceptionTest09 {
    public static void main(String[] args) {
        try {
            m1();
        } catch (FileNotFoundException e) {
            // 获取异常的简单描述信息
            String msg = e.getMessage();
            System.out.println(msg); //C:\jetns-agent.jar (系统找不到指定的文件。)
            //打印异常堆栈追踪信息！！！
            //在实际的开发中，建议使用这个。
            // 这行代码要写上，不然出问题也不知道
            e.printStackTrace();
        }
        // 这里程序不耽误执行，很健壮。
        System.out.println("Hello World!");
    }
    private static void m1() throws FileNotFoundException {
        m2();
    }
    private static void m2() throws FileNotFoundException {
        m3();
    }
    private static void m3() throws FileNotFoundException {
        new FileInputStream("C:\\jetns-agent.jar");
    }
}

public class ExceptionTest11 {
    public static void main(String[] args) {

以下代码的执行顺序：
            先执行try...
            再执行finally...
            最后执行 return （return语句只要执行方法必然结束。）

        try {
            System.out.println("try...");
            return;
        } finally {
            // finally中的语句会执行。能执行到。
            System.out.println("finally...");
        }

这里不能写语句，因为这个代码是无法执行到的。
        //System.out.println("Hello World!");
    }
}

public class ExceptionTest12 {
    public static void main(String[] args) {
        try {
            System.out.println("try...");
            // 退出JVM
            System.exit(0); // 退出JVM之后，finally语句中的代码就不执行了！
        } finally {
            System.out.println("finally...");
        }
    }
}

public class ExceptionTest13 {
    public static void main(String[] args) {
        int result = m();
        System.out.println(result); //100
    }
//----------------------------------------------------------------------------------------
java语法规则（有一些规则不能破坏）：
            方法体中的代码必须遵循自上而下顺序依次逐行执行。
            return语句一旦执行，整个方法必须结束。
//----------------------------------------------------------------------------------------
    public static int m(){
        int i = 100;
        try {
            // 这行代码出现在int i = 100;的下面，所以最终结果必须是返回100
            // return语句还必须保证是最后执行的。一旦执行，整个方法结束。
            return i;
        } finally {
            i++;
        }
    }
//----------------------------------------------------------------------------------------
反编译之后的效果
	public static int m(){
    	int i = 100;
    	int j = i;
    	i++;
    	return j;
}

}

public void push(Object obj) throws MyStackOperationException {
        if(index >= elements.length - 1){
// 改良之前
           System.out.println("压栈失败，栈已满！");
           return;

// 方案1，创建异常对象，手动将异常抛出去
            //MyStackOperationException e = new MyStackOperationException("压栈失败，栈已满！");
            //throw e; //这里捕捉没有意义，自己new一个异常，自己捉，没有意义。栈已满这个信息你需要传递			出去。

// 方案2，合并（手动抛出异常！）
            throw new MyStackOperationException("压栈失败，栈已满！");
        }
    }

public class MyStackOperationException extends Exception{ // 编译时异常！

    public MyStackOperationException(){
    }
    public MyStackOperationException(String s){
        super(s);
    }
}

boolean add(Object e) 向集合中添加元素
int size()  获取集合中元素的个数
void clear() 清空集合
boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false
boolean remove(Object o) 删除集合中的某个元素。
boolean isEmpty()  判断该集合中元素的个数是否为0
Object[] toArray()  调用这个方法可以把集合转换成数组。【作为了解，使用不多。】

import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest01 {
    public static void main(String[] args) {
        // 创建一个集合对象
        //Collection c = new Collection(); // 接口是抽象的，无法实例化。
        // 多态
        Collection c = new ArrayList();
        // 测试Collection接口中的常用方法
        c.add(1200); // 自动装箱(java5的新特性。),实际上是放进去了一个对象的内存地址。Integer x = new Integer(1200);
        c.add(3.14); // 自动装箱
        c.add(new Object());
        c.add(new Student());
        c.add(true); // 自动装箱
//----------------------------------------------------------------------------------------
        // 获取集合中元素的个数
        System.out.println("集合中元素个数是：" + c.size()); // 5
//----------------------------------------------------------------------------------------
        // 清空集合
        c.clear();
        System.out.println("集合中元素个数是：" + c.size()); // 0
//----------------------------------------------------------------------------------------
        // 再向集合中添加元素
        c.add("hello"); // "hello"对象的内存地址放到了集合当中。
        c.add("world");
        c.add("浩克");
        c.add("绿巨人");
        c.add(1);
//----------------------------------------------------------------------------------------
        // 判断集合中是否包含"绿巨人"
        boolean flag = c.contains("绿巨人");
        System.out.println(flag); // true
        boolean flag2 = c.contains("绿巨人2");
        System.out.println(flag2); // false
        System.out.println(c.contains(1)); // true
//----------------------------------------------------------------------------------------
        System.out.println("集合中元素个数是：" + c.size()); // 5

        // 删除集合中某个元素
        c.remove(1);
        System.out.println("集合中元素个数是：" + c.size()); // 4
//----------------------------------------------------------------------------------------
        // 判断集合是否为空（集合中是否存在元素）
        System.out.println(c.isEmpty()); // false
        // 清空
        c.clear();
        System.out.println(c.isEmpty()); // true（true表示集合中没有元素了！）

        c.add("abc");
        c.add("def");
        c.add(100);
        c.add("helloworld!");
        c.add(new Student());
//----------------------------------------------------------------------------------------
        // 转换成数组（了解，使用不多。）
        Object[] objs = c.toArray();
        for(int i = 0; i < objs.length; i++){
            // 遍历数组
            Object o = objs[i];
            System.out.println(o);
        }
    }
}
class Student{

}

boolean hasNext()如果仍有元素可以迭代，则返回 true。
Object next() 返回迭代的下一个元素。

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class CollectionTest02 {
    public static void main(String[] args) {
         // 创建集合对象
        Collection c1  = new ArrayList(); // ArrayList集合：有序可重复
        // 添加元素
        c1.add(1);
        c1.add(2);
        c1.add(3);
        c1.add(4);
        c1.add(1);
        // 迭代集合
        Iterator it = c1.iterator();
        while(it.hasNext()){
            // 存进去是什么类型，取出来还是什么类型。
            Object obj = it.next();
            if(obj instanceof Integer){
                System.out.println("Integer类型");
            }
            // 只不过在输出的时候会转换成字符串。因为这里println会调用toString()方法。
            System.out.println(obj);
        }
          
        Collection c2 = new HashSet();// HashSet集合：无序不可重复
        // 无序：存进去和取出的顺序不一定相同。
        // 不可重复：相同值覆盖。
        c2.add(100);
        c2.add(200);
        c2.add(300);
        c2.add(90);
        c2.add(400);
        c2.add(50);
        c2.add(60);
        c2.add(100);
        Iterator it2 = c2.iterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
    }
}

while(it2.hasNext()){
        Object o = it2.next();
		Collection c2 = new ArrayList();
        // 出异常根本原因是：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化了）
        c2.remove(o); // 直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不				同。）
		Iterator it2 = c2.iterator();
        // 迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）。
        it2.remove(); // 删除的一定是迭代器指向的当前元素。
}

void add(int index, Object element)
Object set(int index, Object element)
Object get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
Object remove(int index)

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class ListTest01 {
    public static void main(String[] args) {
        // 创建List类型的集合。
        //List myList = new LinkedList();
        //List myList = new Vector();
        List myList = new ArrayList();
//----------------------------------------------------------------------------------------
        // 添加元素
        myList.add("A"); // 默认都是向集合末尾添加元素。
        myList.add("B");
        myList.add("C");
        myList.add("C");
        myList.add("D");
//----------------------------------------------------------------------------------------
        //在列表的指定位置插入指定元素（第一个参数是下标）
        // 这个方法使用不多，因为对于ArrayList集合来说效率比较低。
        myList.add(1, "KING");
//----------------------------------------------------------------------------------------
        // 迭代
        Iterator it = myList.iterator();
        while(it.hasNext()){
            Object elt = it.next();
            System.out.println(elt);
        }
//----------------------------------------------------------------------------------------
        // 根据下标获取元素
        Object firstObj = myList.get(0);
        System.out.println(firstObj);
        // 因为有下标，所以List集合有自己比较特殊的遍历方式
        // 通过下标遍历。【List集合特有的方式，Set没有。】
        for(int i = 0; i < myList.size(); i++){
            Object obj = myList.get(i);
            System.out.println(obj);
        }
//----------------------------------------------------------------------------------------
        // 获取指定对象第一次出现处的索引。
        System.out.println(myList.indexOf("C")); // 3
//----------------------------------------------------------------------------------------
        // 获取指定对象最后一次出现处的索引。
        System.out.println(myList.lastIndexOf("C")); // 4
//----------------------------------------------------------------------------------------
        // 删除指定下标位置的元素
        // 删除下标为0的元素
        myList.remove(0);
        System.out.println(myList.size()); // 5
        System.out.println("====================================");
//----------------------------------------------------------------------------------------
        // 修改指定位置的元素
        myList.set(2, "Soft");
    }
}

new ArrayList();
new ArrayList(20);

// 创建一个HashSet集合
Collection c = new HashSet();
// 通过这个构造方法就可以将HashSet集合转换成List集合。
List myList3 = new ArrayList(c);
for(int i = 0; i < myList3.size(); i++){
    System.out.println(myList3.get(i));

// LinkedList集合有初始化容量吗？没有。
// 最初这个链表中没有任何元素。first和last引用都是null。
// 不管是LinkedList还是ArrayList，以后写代码时不需要关心具体是哪个集合。
// 因为面向接口编程，调用的方法都是接口中的方法。
        List list2 = new ArrayList(); // 这样写表示底层用数组。
        List list2 = new LinkedList(); // 这样写表示底层用双向链表。
        // 以下方法面向接口编程。
        list2.add("123");
        list2.add("456");
        list2.add("789");
        for(int i = 0; i < list2.size(); i++){
            System.out.println(list2.get(i));
        }

List myList = new ArrayList(); // 非线程安全的。
Collections.synchronizedList(myList);// 变成线程安全的

for(元素类型 变量名 : 数组或集合){
    System.out.println(变量名);
}

public class ForEachTest02 {
    public static void main(String[] args) {
        // 创建List集合
        List<String> strList = new ArrayList<>();

        // 添加元素
        strList.add("hello");
        strList.add("world!");
        strList.add("kitty!");

        // 遍历，使用迭代器方式
        Iterator<String> it = strList.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }

        // 使用下标方式（只针对于有下标的集合）
        for(int i = 0; i < strList.size(); i++){
            System.out.println(strList.get(i));
        }

        // 使用foreach
        for(String s : strList){ // 因为泛型使用的是String类型，所以是：String s
            System.out.println(s);
        }

        List<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        for(Integer i : list){ // i代表集合中的元素
            System.out.println(i);
        }
    }
}

public class GenericTest02 {
    public static void main(String[] args) {
        // ArrayList<这里的类型会自动推断>()，前提是JDK8之后才允许。
        // 自动类型推断，原本为List<String> strList = new ArrayList<String>();
        List<String> strList = new ArrayList<>();
        // 类型不匹配。
        //strList.add(new Cat());
        strList.add("http://www.126.com");
        strList.add("http://www.baidu.com");
        strList.add("http://www.bjpowernode.com");
        // 类型不匹配。
        //strList.add(123);
        //System.out.println(strList.size());

        // 遍历
        Iterator<String> it2 = strList.iterator();
        while(it2.hasNext()){
            // 如果没有使用泛型
            /*
            Object obj = it2.next();
            if(obj instanceof String){
                String ss = (String)obj;
                ss.substring(7);
            }
             */
            // 直接通过迭代器获取了String类型的数据
            String s = it2.next();
            // 直接调用String类的substring方法截取字符串。
            String newString = s.substring(7);
            System.out.println(newString);
        }
    }
}

public class GenericTest03<标识符随便写> {

    public void doSome(标识符随便写 o){
        System.out.println(o);
    }
    
    public static void main(String[] args) {

        // new对象的时候指定了泛型是：String类型
        GenericTest03<String> gt = new GenericTest03<>();
        // 类型不匹配
        //gt.doSome(100);
        gt.doSome("abc");

        MyIterator<String> mi = new MyIterator<>();
        String s1 = mi.get();

        // 不用泛型就是Object类型。
        /*GenericTest03 gt3 = new GenericTest03();
        gt3.doSome(new Object());*/
    }
}
class MyIterator<T> {
    public T get(){
        return null;
    }
}

   V put(K key, V value) 					向Map集合中添加键值对
   V get(Object key) 						通过key获取value
   void clear()    						清空Map集合
   boolean containsKey(Object key) 		判断Map中是否包含某个key
   boolean containsValue(Object value) 	判断Map中是否包含某个value
   boolean isEmpty()   					判断Map集合中元素个数是否为0
   V remove(Object key) 					通过key删除键值对
   int size() 							获取Map集合中键值对的个数。
   Collection<V> values() 				获取Map集合中所有的value，返回一个Collection
Set<K> keySet() 						获取Map集合所有的key（所有的键是一个set集合）
   Set<Map.Entry<K,V>> entrySet()			将Map集合转换成Set集合

public class MapTest01 {
    public static void main(String[] args) {
        // 创建Map集合对象
        Map<Integer, String> map = new HashMap<>();
        // 向Map集合中添加键值对
        map.put(1, "zhangsan"); // 1在这里进行了自动装箱。
        map.put(2, "lisi");
        map.put(3, "wangwu");
        map.put(4, "zhaoliu");
        // 通过key获取value
        String value = map.get(2);
        System.out.println(value);
        // 获取键值对的数量
        System.out.println("键值对的数量：" + map.size());
        // 通过key删除key-value
        map.remove(2);
        System.out.println("键值对的数量：" + map.size());
        // 判断是否包含某个key
        // contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法。
        System.out.println(map.containsKey(new Integer(4))); // true
        // 判断是否包含某个value
        System.out.println(map.containsValue(new String("wangwu"))); // true

        // 获取所有的value
        Collection<String> values = map.values();
        // foreach
        for(String s : values){
            System.out.println(s);
        }

        // 清空map集合
        map.clear();
        System.out.println("键值对的数量：" + map.size());
        // 判断是否为空
        System.out.println(map.isEmpty()); // true
    }
}

Map<Integer, String> map = new HashMap<>();
map.put(1, "zhangsan");
map.put(2, "lisi");
map.put(3, "wangwu");
map.put(4, "zhaoliu");
// 遍历Map集合
// 获取所有的key，所有的key是一个Set集合
Set<Integer> keys = map.keySet();
// 遍历key，通过key获取value
/*迭代器
Iterator<Integer> it = keys.iterator();
while(it.hasNext()){
    // 取出其中一个key
    Integer key = it.next();
    // 通过key获取value
    String value = map.get(key);
    System.out.println(key + "=" + value);
}
*/
// foreach
for(Integer key : keys){
    System.out.println(key + "=" + map.get(key));
}

// 把Map集合直接全部转换成Set集合。
// Set集合中元素的类型是：Map.Entry，是Map中的静态内部类
Set<Map.Entry<Integer,String>> set = map.entrySet();
// 遍历Set集合，每一次取出一个Node
/*迭代器
Iterator<Map.Entry<Integer,String>> it2 = set.iterator();
while(it2.hasNext()){
    Map.Entry<Integer,String> node = it2.next();
    Integer key = node.getKey();
    String value = node.getValue();
    System.out.println(key + "=" + value);
}
*/
// foreach
// 这种方式效率比较高，因为获取key和value都是直接从node对象中获取的属性值。
// 这种方式比较适合于大数据量。
for(Map.Entry<Integer,String> node : set){
    System.out.println(node.getKey() + "--->" + node.getValue());
}

public class HashSetTest01 {
    public static void main(String[] args) {
        // 演示一下HashSet集合特点
        Set<String> strs = new HashSet<>();
        // 添加元素
        strs.add("hello3");
        strs.add("hello4");
        strs.add("hello1");
        strs.add("hello2");
        strs.add("hello3");
        strs.add("hello3");
        strs.add("hello3");
        strs.add("hello3");
        /*遍历
        hello1
        hello4
        hello2
        hello3
        1、存储时顺序和取出的顺序不同。
        2、不可重复。
        3、放到HashSet集合中的元素实际上是放到HashMap集合的key部分了。
         */
        for(String s : strs){
            System.out.println(s);
        }
    }
}

public class HashMap{
    // HashMap底层实际上就是一个数组。（一维数组）
    Node<K,V>[] table;
    // 静态的内部类HashMap.Node
    static class Node<K,V> {
        final int hash; // 哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组的下标。）
        final K key; // 存储到Map集合中的那个key
        V value; // 存储到Map集合中的那个value
        Node<K,V> next; // 下一个节点的内存地址。
    }
}

map.put(k,v)
v = map.get(k)