Java总结

第六次

static关键词

静态关键字
主函数有static修饰-静态函数，全局变量static修饰
主要用于修饰成员变量（对象的特有属性）和成员函数，变为静态变量和静态函数
静态变量最大的特点是同类下多个对象之间的共有属性
什么时候定义静态变量呢？在同一类下，多个对象之间有相同的属性和值，那么就可以将该属性和值从
成员变量变为静态变量，目的就是为了节省空间。
什么时候去定义静态函数呢？只有一点，当一个成员函数不访问成员时，即可定义为静态函数！
静态函数一旦定义出来，可以直接用类名去调用（Math.sqrt()）,当然也可以通过创建对象来去调用静态
函数！
静态优先于对象存在，且在同一类中，静态无法访问非静态（成员），非静态是可以访问静态
静态方法没有this关键字
静态方法只能访问静态成员变量和静态成员方法

• static方法
  static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。
• static变量
  static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
  static成员变量的初始化顺序按照定义的顺序进行初始化。
• static代码块
  static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

静态变量与成员变量

• 存储位置不同
  成员变量存储在堆内存中对象所属空间里
  静态变量存储在静态方法区中对应的字节码空间里
• 生命周期不同
  成员变量随着对象的创建而创建，随着对象的消亡而消亡
  静态变量随着类的加载而存在，随着程序的结束而消失
• 所属不同
  成员变量属于对象的，称之为是对象的特有属性
  静态变量属于类的，称之为是类的属性，或者叫对象的共有属性
• 调用方式不同
  成员变量只能被对象调用。
  静态变量可以被对象调用，还可以被类名调用。
  成员变量在外界必须通过创建对象来调用，内部的话成员函数可以直接调用成员变量，但是静态函数不能直接调用成员变量，如果非要在静态函数中调用成员的话，只能创建对象，通过对象来调用静态变量在外界可以通过对象调用，也可以通过类来调用，内部的话静态函数/成员函数可以调用静态变量

第五次

面向过程与面向对象思想

1. 面向过程
   当我们在解决一个问题时，会按照预先设定的想法和步骤，一步一步去实现，在这里每一步具体的
   实现中都需要我们自己去亲自实现和操作。
   举个例子：自己做->买菜->洗菜->切菜->炒菜->吃
   我们的角色是： 执行者
   特点：费时间、费精力、结果也不一定完美
   面向对象
   当我们在解决一个问题时，可以去找具有相对应的功能的事物帮着我们去解决问题，至于这个事物
   如何工作，与我们无关，我们只看结果，不关心解决流程。
   举个例子：叫外卖->下单->餐馆做饭->骑手送餐->吃
   我们的角色是： 指挥者
   特点：节省时间，节省精力，结果相对完美
   面向过程是面向对象的基础，问题可以自己不解决托给别人解决，别人也可以在再托给别人，但最
   终，事情必须要处理掉，一旦处理就是面向过程
   面向对象和面向过程差异
   面向对象是一种符合人们思考习惯的思想
   面向过程中更多的体现是执行者，面向对象中更多的体现是指挥者。
   面向对象可以将复杂的问题进行简单化，更加贴近真实的社会场景

2. 类与对象的关系
   什么是对象
   面向对象编程语言主要是使用对象们来进行相关的编程。对象，万事万物中存在的每一个实例，一
   个电脑、一个手机、一个人、抖音里的一个短视频、支付宝里的一个交易记录、淘宝里的订单。
   如何去描述一个对象的内容？
   对象的属性：就是对象的相关参数，可以直接用数据来衡量的一些特征——常量|变量来表示
   （成员变量）
   对象的行为：就是过将对象的属性进行联动，产生出一系列的动作或行为——函数（成员函
   数）
   什么是类
   类是那些具有相同属性特征和行为的对象们的统称。对象就是该类描述下具体存在的一个事物。

封装与private关键字

封装-包装

1. 常见的封装体现
   函数
   类

2. 封装有什么好处？
   提高了安全性
   向外界隐藏了一些不需要被外界获知的内容
   提高了代码的复用性
   也是面向对象的三大特点之一：封装 继承 多态
   封装不是封死，还是要向外提供一些访问内部内容的方法
   private关键字，属于权限关键字 public protected 默认不写 private
   private可以作用在对象属性和行为上，外界在创建对象后，则不能访问被private修饰的内容
   总结：
   类中不需要对外界提供的内容，最好都私有化
   如果后续真的需要对私有的内容进行更改，最好加上setXXX修改器，getXXX访问器

3. 不可变对象或类
   就是指其内部的数据都是私有的，没有向外界提供任何修改内部的方法（String）
   所有的数据都是私有的
   没有修改器的方法

4. 局部变量和成员变量有什么区别？

• 生命周期
  成员变量随着对象的创建而创建，随着对象的消亡而消失
  局部变量随着函数的进栈而创建，随着函数的出栈而消失
• 存储位置
  成员变量在堆内存中对象所属空间里
  局部变量在栈内存中函数所属空间里
• 定义位置
  成员函数在类中，函数外定义
  局部变量在函数中定义
• 初始化
  成员变量有默认初始化
  局部变量必须初始化之后再调用

构造函数

构造函数 ，是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们,即构造函数的重载

• 构造函数的特点
  构造函数的主要作用是完成对象的初始化工作，(如果写的类里面没有构造函数,那么编译器会默认加上一个无参数且方法体为空的构造函数).
  构造函数的名称必须与类名相同,包括大小写;
  构造函数没有返回值,也不能用void修饰. 如果不小心给构造函数前面添加了返回值类型，那么这将使这个构造函数变成一个普通的方法，在运行时将产生找不到构造方法的错误。
  一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。
  构造方法可以重载，以参数的个数，类型，顺序
  虽然构造函数没有返回值，还是存在return关键字的
  当我们的类中没有定义任何构造函数时，会有一个默认隐藏的无参构造函数存在
  构造函数和成员函数一样，为了区分对象的调用，构造函数自带this关键字数据
• 需要注意的问题
  如果一旦定义其他参数列表的构造函数的话，这个隐藏的无参构造函数就会消失，所建议手写出来
  构造函数只有在创建对象的时候执行，当对象创建完毕之后，该对象的构造函数则不能执行
  成员函数只有在对象创建之后才能执行
  成员函数能否直接调用构造函数？不能够的，报找不到符号错误 会误认为是同名的成员函数
  构造函数能否直接调用成员函数呢？能够，但是 这些成员函数一般是构造函数的部分代码片段被切割
  出来了而已，从语意上而言，不属于对象的特有行为（也有特例），所以这些函数长得样子就是成员函数
  的样子，但没有必要向外界提供访问，所以加上private
  构造函数能否直接调用构造函数呢？可以，但是必须通过 this(参数列表) ，需要注意的是，构造
  函数可以单向调用其他构造函数，但坚决不能出现回调。
  构造函数是在创建对象的时候执行的，可以在期间对成员变量进行初始化，问：setXXX还需要不？
  看需求，如果后期成员变量需要修改，则提供setXXX修改器

第四次

二维数组

二维数组，在表现形式上就是一个表格，在操作表格的时候以行列来操作
所谓的二维数组，本质上就是一个一维数组，只不过该一维数组里面的元素是另一个一维数组而已

二维数组的定义

public class Sample {
public static void main(String[] args) {
	//数据类型[][] 矩阵名 = new 数据类型[row][col];
	int[][] matrix = new int[3][2];
	/*
	数据类型[][] 矩阵名 = new 数据类型[][] {
		{...},
		{...},
		{...}
	};
	数据类型[][] 矩阵名 = {
		{...},
		{...},
		{...}
	};
	*/
	int[][] matrix2 = {
		{1,2,3},
		{4,5,6},
		{7,8,9}
	};
		for (int i = 0; i < matrix2.length; i++) {
			for (int j = 0; j < matrix2[i].length; j++) {
				System.out.print(matrix2[i][j] + " ");
			}
		System.out.println();
		}
	int[][] matrix3 = {
		{1},
		{1,2,3},
		{1,2,3,4},
		{7,6,5,4,3,2,1}
	};
		for (int i = 0; i < matrix3.length; i++) {
			for (int j = 0; j < matrix3[i].length; j++) {
				System.out.print(matrix3[i][j] + " ");
			}
		System.out.println();
		}
	}
}

import java.util.*;
public class Demo88 {
public static void main(String[] args) {
	Scanner input = new Scanner(System.in);
	Random random = new Random();
	System.out.print("请输入球的个数：");
	int balls = input.nextInt();
	System.out.print("请输入槽子的个数：");
	int slots = input.nextInt();
	int[] temp = new int[slots]; //槽子的数组
	//路径的个数
	String[] paths = new String[balls];
	for (int i = 0; i < paths.length; i++) {
		String path = "";
		int rCount = 0;
			//拼接每一个路径
			for (int j = 0; j < slots - 1; j++) {
				if (random.nextInt(2) == 0) {
					path += "L";
				} else {
					path += "R";
					rCount++;
				}
			}
		paths[i] = path;
		System.out.println(path);
		temp[rCount]++;
	}
	System.out.println(Arrays.toString(temp));
	}
}

import java.util.*;
public class demo92 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Random random = new Random();
        String[] words = {"banana","orange","python","apple","computer"};

        while (true) {
            //1.随机抽取一个单词
            String word = words[random.nextInt(words.length)];
            //2.创建该单词的状态数组
            boolean[] statues = new boolean[word.length()];
            int missed = 0; //错误的次数
            
            //开始下一个字母的输入
            while (!isOver(statues)) {
                //3.按照状态数组获取提示的密文
                String password = getPassword(word,statues);
                //4.提示用户输入一个字母
                System.out.print("Enter a letter " + password + ":" );
                String letter = input.nextLine();
                //5.判断这个字母是否出现在字符串中
                if (word.contains(letter)) {
                    //6.改变字母的状态
                    if (!changeStatues(word,letter,statues)) {
                        System.out.println("\t" + letter + " is alreay in the word");
                    }
                } else {
                    System.out.println("\t" + letter + " is not in the word");
                    missed++;
                }
            }
            System.out.println("The word is " + word + ". You missed " + missed);
            System.out.print("Do you again?(y/n)");
            String choice = input.nextLine();
            if (choice.equals("n")) {
                break;
            }
        }
    }
    public static boolean changeStatues(String word,String letter,boolean[] statues) {
        //"a" -> 'a'
        char ch = letter.charAt(0);
        for (int i = 0; i < word.length(); i++) {
            if (word.charAt(i) == ch) {
                if (statues[i]) { //如果字符所在的角标i对应的状态已经是true 表示此次没有改变成功-重复输入的字符
                    return false;
                } else {
                    statues[i] = true;
                }
            }
        }
        return true;
    }
    public static boolean isOver(boolean[] statues) {
        for (int i = 0; i < statues.length; i++) {
            if (!statues[i]) {
                return false;
            }
        }
        return true;
    }
    public static String getPassword(String word,boolean[] statues) {
        String password = "";
        for (int i = 0; i < statues.length; i++) {
            if (statues[i]) {
                 password += word.charAt(i);
            } else {
                password += "*";
            }
        }
        return password;
    }
}

在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法

public class zuoye {
    public static int N = 8;
    public static int[][] board = new int[N][N];
    public static int count = 0;
    public static void main(String[] args) {
        nqueen(0);
    }
    public static void nqueen(int row) {
        if (row == N) {
            count++;
            System.out.printf("这是第%d种解法：\n",count);
                for (int i = 0; i < board.length; i++) {
                    for (int j = 0; j < board[i].length; j++) {
                        System.out.print(board[i][j] + " ");
                    }
                System.out.println();
            }
        } else {
            for (int col = 0; col < N; col++) {
                if (!isDangerous(row,col)) {
                    for (int c = 0; c < N; c++) {
                        board[row][c] = 0;
                    }
                    board[row][col] = 1;
                    nqueen(row + 1);
                }
            }
        }
    }
    public static boolean isDangerous(int row ,int col) {
        //向上
        for (int r = row - 1;r >= 0; r--) {
            if (board[r][col] == 1) {
                return true;
            }
        }
        //向左上
        for (int r = row - 1,c = col - 1; r >= 0 && c >= 0;r--,c--) {
            if (board[r][c] == 1) {
                return true;
            }
        }
        //向右上
        for (int r = row - 1,c = col + 1; r >= 0 && c < N; r--,c++) {
            if (board[r][c] == 1) {
                return true;
            }
        }
        return false;
    }
}

第三次

函数

什么是函数
函数的定义就是指一段具有独立功能的代码，减少代码冗余，提高程序的利用率和效率。
我们应该如何去定义函数呢？
需要一个封闭的空间，将这段独立性的代码进行封装，用一对大括号
需要对每一个封闭的空间进行命名，函数名
函数所需要的一些原始数据
函数所产生的一些结果数据
函数的语法格式
修饰符 函数类型 返回值类型 函数名(数据类型 数据1,数据类型 数据2,…) {
独立功能的代码片段;
return 函数的计算结果;
}
修饰符：指的是函数的访问权限，public private 默认 protected
函数类型：函数的分类，本地函数native，静态函数static，同步函数 synchronized返回值类型：指的就是函数计算结果的数据类型 如果函数没有返回值 则为void 函数名：就是函数的名称
参数列表：指的是外界向函数传入的数据（实际参数），由这些参数变量进行接收（形式参数）
函数体：具有独立功能的代码片段；
return：仅仅表示函数结束！如果函数有返回值，则return后跟返回值；如果没有返回值，则return可以不写，但是是存在的（隐藏的 在最后一行）
根据形参和返回值来看，函数有如下几个分类
有参数有返回值
有参数无返回值
无参数有返回值
无参数无返回值

函数的运行是基于栈运行的
栈：是一种先进后出的容器，我们这里面所说的栈是指JVM中的栈内存空间
每一个函数，叫做栈帧，栈帧中所包含的内容有函数的定义，参数列表，函数的执行内容代码每一个函数要运行，就相当于这个栈帧进入到栈内存中-入栈如果一个函数即将结束，将这个栈帧从栈顶移出-出栈如果栈内存中有多个栈帧，运行的是最上面的栈帧，底下的栈帧暂停运行，直到该栈帧为栈顶元素比如：主函数先进栈，开始逐行运行，如果执行到第n行，调用另外一个函数A，则主函数在第n行暂停运行，将另一个函数A的栈帧入栈，再继续逐行运行，直到函数A的内容执行完毕，函数A出栈，主函数接着从第n行继续向下执行。以此类推。
函数重载
同一个类中可以出现多个同名函数，这个现象就叫做函数的重载（overload）如何来区分同名函数是否是重载关系呢？前提必须是同名，和返回值类型无关（返回值类型只和函数的计算功能相关），和权限也没有关系，和形式参数的名称也无关！只和形式参数的数据类型有关（数量，排列组合）
寻找重载函数的流程：
看是否有确切的参数定义匹配，int int 找 int int
看是否有可兼容的参数定义匹配，int int找double double或int double或double int
如果可兼容的参数定义匹配较多，会报引用确定报错 引用不明确
函数的递归
函数的递归就是指函数自身调用自身。
但凡迭代能够解决的问题，递归都可以解决；递归能够解决的问题，迭代就不一定了
相对而言，从内存的角度而言，函数如果过多的自我调用，势必会对内存不友好，占用过多
通常来讲，同样的问题用递归写要比用迭代写代码量较少
写递归时，一定要先确定递归结束条件-递归边界

数组

数组主要用于解决大量数据计算与存储的问题
比如：输入100个数字，统计其中的最大值和最小值并计算平均值，创建100个变量，会有一堆ifelse语句，比较麻烦。
数组是Java提供的一种最简单的数据结构，可以用来存储一个元素 个数固定 且 类型相同 的有序集。
数组在内存中的情况
栈：主要用于运行函数的内存
堆：主要用于存储数据对象的内存
每一个数组而言，都是存在堆内存当中，每一个数组都是一个对象
数组本质上就是在堆内存中一系列地址连续且空间大小相等的存储空间（变量），每一个存
储空间用来存储数据（基本，引用）
数组是在堆内存中存储，称之为是一个对数对象，并且在堆内存中存储的数据都有 默认初始
化 的流程。所以数组创建之初，每一个存储空间里面都会被JVM初始化该数据类型对应的零值。
数组的地址是连续的，所以通过公式：An=A1+(n-1)*d可以快速访问到其他的元素，所以对于
数组而言查找元素比较快的。将元素的真实物理地址转换成对应的角标获取元素。
如何来调用数组呢？通过一个变量存储该数组在堆内存当中的首元素的地址。
当数组一旦定义出来，其长度不可变，存储空间的内容是可变的
所以我们在定义数组的时候，要么把长度固定，要么直接输入相关的元素。
数组的定义方式
创建一个指定长度且指定数据类型的一维数组，名称为数组名，虽然没有指定元素，但是会有默认值
数据类型[] 数组名 = new 数据类型[长度];
创建一个指定元素且指定数据类型的一维数组，名称为数组名，虽然有指定元素，还是有默认初始化这个步骤的！
数据类型[] 数组名 = new 数据类型[]{数据1,数据2,…,数据n};
数据类型[] 数组名 = {数据1,数据2,…,数据n};

第二次

math类

static double abs(double a)
返回 double 值的绝对值。
static float abs(float a)
返回 float 值的绝对值。
static int abs(int a)
返回 int 值的绝对值。
static long abs(long a)
返回 long 值的绝对值。
static double acos(double a)
返回角的反余弦，范围在 0.0 到 pi 之间。
static double asin(double a)
返回角的反正弦，范围在 -pi/2 到 pi/2 之间。
static double atan(double a)
返回角的反正切，范围在 -pi/2 到 pi/2 之间。
static double atan2(double y, double x)
将矩形坐标 (x, y) 转换成极坐标 (r, theta)。
static double cbrt(double a)
返回 double 值的立方根。
static double ceil(double a)
返回最小的（最接近负无穷大）double 值，该值大于或等于参数，并且等于某个整数。
static double cos(double a)
返回角的三角余弦。
static double cosh(double x)
返回 double 值的双曲线余弦。
static double exp(double a)
返回欧拉数 e 的 double 次幂的值。
static double expm1(double x)
返回 ex -1。
static double floor(double a)
返回最大的（最接近正无穷大）double 值，该值小于或等于参数，并且等于某个整数。
static double hypot(double x, double y)
返回 sqrt(x2 +y2)，没有中间溢出或下溢。
static double IEEEremainder(double f1, double f2)
按照 IEEE 754 标准的规定，对两个参数进行余数运算。
static double log(double a)
返回（底数是 e）double 值的自然对数。
static double log10(double a)
返回 double 值的底数为 10 的对数。
static double log1p(double x)
返回参数与 1 的和的自然对数。
static double max(double a, double b)
返回两个 double 值中较大的一个。
static float max(float a, float b)
返回两个 float 值中较大的一个。
static int max(int a, int b)
返回两个 int 值中较大的一个。
static long max(long a, long b)
返回两个 long 值中较大的一个。
static double min(double a, double b)
返回两个 double 值中较小的一个。
static float min(float a, float b)
返回两个 float 值中较小的一个。
static int min(int a, int b)
返回两个 int 值中较小的一个。
static long min(long a, long b)
返回两个 long 值中较小的一个。
static double pow(double a, double b)
返回第一个参数的第二个参数次幂的值。
static double random()
返回带正号的 double 值，大于或等于 0.0，小于 1.0。
static double rint(double a)
返回其值最接近参数并且是整数的 double 值。
static long round(double a)
返回最接近参数的 long。
static int round(float a)
返回最接近参数的 int。
static double signum(double d)
返回参数的符号函数；如果参数是零，则返回零；如果参数大于零，则返回 1.0；如果参数小于零，则返回 -1.0。
static float signum(float f)
返回参数的符号函数；如果参数是零，则返回零；如果参数大于零，则返回 1.0；如果参数小于零，则返回 -1.0。
static double sin(double a)
返回角的三角正弦。
static double sinh(double x)
返回 double 值的双曲线正弦。
static double sqrt(double a)
返回正确舍入的 double 值的正平方根。
static double tan(double a)
返回角的三角正切。
static double tanh(double x)
返回 double 值的双曲线余弦。
static double toDegrees(double angrad)
将用弧度测量的角转换为近似相等的用度数测量的角。
static double toRadians(double angdeg)
将用度数测量的角转换为近似相等的用弧度测量的角。
static double ulp(double d)
返回参数的 ulp 大小。
static float ulp(float f)
返回参数的 ulp 大小

Scanner类

主要用于负责数据输入的类，底层是和IO流相关。
String next()：获取直到遇到空格为止的一个字符串
String nextLine()：获取直到遇到回车为止的一个字符串
int nextInt()：获取下一个整数 byte short long
double nextDouble()
boolean nextBoolean()
float nextFloat()

Random类

主要用于产生随机数
boolean nextBoolean()：随机产生布尔类型值
double nextDouble()：随机生成0.0~1.0之间的小数
double nextInt()：随机生成一个整数0~2
32的整数
double nextInt(n)：随机生成一个整数[0,n)的整数

String类

1、String类是baifinal的，不可被继承。public final class String。
　　2、String类是的本质是字符数组char[], 并且其值不可改变。private final char value[];
　　然后打开String类的API文档，可以发现：
　　3、String类对象有个特殊的创建的方式，就是直接指定比如String x = “abc”，"abc"就表示一个字符串对象。而x是"abc"对象的地址，也叫
　　做"abc"对象的引用。
　　4、String对象可以通过“+”串联。串联后会生成新的字符串。也可以通过concat()来串联，这个后面会讲述。
　　6、Java运行时会维护一个String Pool（String池），JavaDoc翻译很模糊“字符串缓冲区”。String池用来存放运行时中产生的各种字符串，
　　并且池中的字符串的内容不重复。而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区。
　　5、创建字符串的方式很多，归纳起来有三类：
　　其一，使用new关键字创建字符串，比如String s1 = new String(“abc”);
　　其二，直接指定。比如String s2 = “abc”;
　　其三，使用串联生成新的字符串。比如String s3 = “ab” + “c”;
　　二、String对象的创建
　　原理1：当使用任何方式来创建一个字符串对象s时，Java运行时（运行中JVM）会拿着这个X在String池中找是否存在内容相同的字符串对象，
　　如果不存在，则在池中创建一个字符串s，否则，不在池中添加。
　　原理2：Java中，只要使用new关键字来创建对象，则一定会（在堆区或栈区）创建一个新的对象。
　　原理3：使用直接指定或者使用纯字符串串联来创建String对象，则仅仅会检查维护String池中的字符串，池中没有就在池中创建一个，有则罢
　　了！但绝不会在堆栈区再去创建该String对象。
　　原理4：使用包含变量的表达式来创建String对象，则不仅会检查维护String池，而且还会在堆栈区创建一个String对象。
　　另外，String的intern()方法是一个本地方法，定义为public native String intern(); intern()方法的价值在于让开发者能将注意力集中到
　　String池上。当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则返回池
　　中的字符串。否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。
　　三、不可变类
　　不可改变的字符串具有一个很大的优点：编译器可以把字符串设置为共享。
　　不可变类String有一个重要的优点－它们不会被共享引用。
　　是这样的，JAVA为了提高效率，所以对于String类型进行了特别的处理－－－为string类型提供了串池
　　定义一个string类型的变量有两种方式：
　　string name= "tom ";
　　string name =new string( "tom ")
　　使用第一种方式的时候，就使用了串池，
　　使用第二中方式的时候，就是一种普通的声明对象的方式
　　如果你使用了第一种方式，那么当你在声明一个内容也是 "tom "的string时，它将使用串池里原来的那个内存，而不会重新分配内存，也就是说，string saname= "tom ",将会指向同一块内存
　　另外关于string类型是不可改变的问题：
　　string类型是不可改变的，也就是说，当你想改变一个string对象的时候，比如name= "madding "
　　那么虚拟机不会改变原来的对象，而是生成一个新的string对象，然后让name去指向它，如果原来的那个 "tom "没有任何对象去引用它，虚拟机的垃圾回收机制将接收它。
char charAt(int index)：获取指定角标index处的字符
int indexOf(int ch)：获取指定字符(编码)在字符串中第一次（从左到右）出现的地方返回的是
角标。如果是-1 表示不存在
int lastIndexOf(int ch)：获取指定字符(编码)在字符串中第一次（从右到做）出现的地方返回的
是角标
int indexOf(String str)：获取指定字符串在本字符串中第一次（从左到右）出现的地方返回的是
角标
int lastIndexOf(String str)：获取指定字符串在本字符串中第一次（从右到左）出现的地方返回
的是角标
int length()：获取字符串的长度（字符的个数）
String[] split(String regex)：将字符串按照regex的定义进行切割（regex指的是正则表达式）
String substring(int beginIndex)：截取一段子字符串，从beginIndex开始到结尾
String substring(int beginIndex, int endIndex)：截取一段子字符串，从beginIndex开始到
endIndex(不包含)
判断相关
int compareTo(String anotherString)：按照字典顺序比较两个字符串的大小
boolean contains(String another)：判断当前字符串中是否包含指定字符串another
boolean equals(String another)：比较当前字符串与指定字符串的内容是否相同
boolean isEmpty()：判断当前字符串是否为空，length() == 0
boolean startsWith(String prefix)：判断该字符串是否以prefix开头
boolean endsWith(String suix)：判断该字符串是否已suix结尾
修改相关
String toLowerCase()：将字符串中所有的英文字母全部变为小写
String toUpperCase()：将字符串中所有的英文字母全部变为大写
String trim()：将字符串中两端的多余空格进行删除
String replace(char oldCh,char newCh)：将字符串中oldCh字符替换成newCh字符

Character类

Character它是char基本数据类型的 包装类 ，有这么几个静态方法我可目前可以使用到的
static boolean isDigit(char ch)：判断字符是否是数字
static boolean isLetter(char ch)：判断字符是否是字母
static boolean isLetterOrDigit(char ch)：判断字符是否是数字或字母
static boolean isLowerCase(char ch)：判断是否是小写字母
static boolean isUpperCase(char ch)：判断是否是大写字母
static boolean isSpaceChar(char ch)：判断是否空白字母（空格 制表符 回车）

1. 关键字
   JAVA的关键字都是小写的
   在JAVA中目前一共有53个关键字：其中由51+2个保留字=53个关键字
   关键字是指被高级编程语言赋予特殊含义的一些单词，关键字一般都是由小写字母组成。
   标识符
   标识符指的是我们在程序中对变量、函数、类、接口、常量所定义的名称
   标识符必须满足以下组成规则：
   1、标识符可以由数字、字母、下划线 _ 、美元符 $ 组成
   标识符不能以数字开头，当然下划线和美元符其实是可以开头的，但不推荐
   2、标识符不能是关键字
   3、标识符也不能是Java内置类的名称
   4、标识符可以为任意长度，但必须是一个连续的词
   5、标识符严格区分大小写
   大驼峰式：主要针对类名，接口名。所有单词的首字母大写
   小驼峰是：主要针对于变量名，函数名。除了第一个单词之外，其他单词首字母大写
   常量规范：所有单词字母大写，单词与单词之间用下划线分隔
   包名规范：所有单词字母小写，单词与单词之间用句号 . 分隔

2. 标识符
   Java 中标识符是为方法、变量或其他用户定义项所定义的名称。标识符可以有一个或多个字符。在 Java 语言中，标识符的构成规则如下。
   标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。
   另外，Java 区分大小写，因此killdog和KillDog 是两个不同的标识符。
   标识符命名时，切记不能以数字开头，也不能使用任何 Java 关键字作为标识符，而且不能赋予标识符任何标准的方法名。
   标识符分为两类，分别为关键字和用户自定义标识符。
   关键字是有特殊含义的标识符，如 true、false 表示逻辑的真假。
   用户自定义标识符是由用户按标识符构成规则生成的非保留字的标识符，如 abc 就是一个标识符。
   使用标识符时一定要注意，或者使用关键字，或者使用自定义的非关键字标识符。此外，标识符可以包含关键字，但不能与关键字重名。
   标识符用来命名常量、变量、类和类的对象等。因此，一个良好的编程习惯要求命名标识符时，应赋予它一个有意义或有用途的名字

3. 变量
   指的是变化的量
   变量的本质就是在内存中程序所处的进程中的一个临时存储区域
   该区域的存储值有限制的
   该区域值的变化必须是同类型的或向下兼容的
   该区域有其自身的物理内存地址-指针
   该区域中 存储值的限制 和 数据的变化类型 由 数据类型 来决定
   该区域中 其空间的分配 和 空间的物理内存地址 由计算机底层来决定

4. 数据类型
   
   

5. 运算符
   算数运算符
   
   

比较运算符
运算的结果为布尔类型

大于
< 小于
= 大于等于
<= 小于等于
!= 不等于
逻辑运算符
& 单与
| 单或
^ 异或
! 非
&& 双与
|| 双或