Java基础知识（个人总结，不具有普遍参考意义）

类：class+类名，类相当于一个模板
方法：能在类里面做什么的就叫做方法
对象：在类下创建的具体的类叫做对象
变量：用来命名一个数据的标识符
类的属性：就比如一个人有名字、年龄、身高等等状态这些状态就叫做一个人的属性。
字面值：给基本类型的变量赋值的方法。
数组：数组是一个固定长度的，包含了相同类型数据的 容器
引用的概念，如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用。
基本数据类型（8）
整型(4种)：用来存放整数
byte 8
short 16
int 32
long 64
字符型（1种）：用来存放一个字符，用单引号
char 16
浮点型（2种）：默认是double型，在数字后面加f或F设置成float类型。
float 32
double 64
布尔型（1种）
boolean 用来表示真假，长度为1.

命名规则
变量命名只能使用字母 数字 $ _
变量第一个字符 只能使用 字母 $ _
变量第一个字符 不能使用数字
最好使用完整的单词，可读性较好
不能使用关键字

关键字列表
1、异常处理
try
catch
finally
throw
throws
2、对象相关
new
extends
implements
class
instanceof
this
super
3、字面值常量
false
true
full
4、方法相关
return
void 没有返回值
5、包相关
import
package
6、未使用的
const
goto
7、基本数据类型
byte
short
int
long
8、分支关键字
if
else
switch
case
default
9、方法、变量和类修饰符
private
public
protected
final
static
abstract
synchronized
transient
volatile
strictfp
10、循环关键字
do
while
for
break
continue

作用域
变量处在不同的位置，有不同的名称
分别是
字段，属性
参数
局部变量

当一个变量被声明在类下面，变量就叫做字段或属性、成员变量、field，当它在方法外时，它的作用域就是从声明的位置开始的整个类。

如果一个变量是声明在一个方法上的，就叫做参数，参数的作用域即为该方法内的所以代码。

声明在方法内的变量，叫做局部变量，其作用域在声明开始的位置，到其所处于的块结束位置。

当一个变量被final修饰的时候，该变量只有一次赋值的机会。

块：从{开始到对应的}结束。

操作符
1、算法操作符
+、-、*、/、%（取余）、++、–
i++; 先取值，再运算
++i; 先运算，再取值
2、关系操作符：比较两个变量之间的关系

、>= 、< 、<= 、== 、!=
3、逻辑操作符

区别
长路与 两侧，都会被运算
短路与 只要第一个是false，第二个就不进行运算了
区别
长路或 两侧都会被运算
短路或 只要第一个是true的，第二个就不进行运算了
异或^，不同，返回真，相同，返回假
4、位操作符
位操作都是对二进制而言的，通过Integer.toBinaryString () 方法，将一个十进制整数转换为一个二进制字符串
Integer.toBinaryString () 一个整数的二进制表达
| 位或
& 位与
^ 异或
~ 取非
<< 左移 >> 右移
5、赋值操作符

6、三元操作符
表达式?值1:值2
如果表达式为真 返回值1
如果表达式为假 返回值2

while 条件为true时 重复执行
do while 条件为true时 重复执行，至少会执行一次

break只能结束内部循环
Boolean变量结束外部循环（下面的代码也没看懂）

数组
数组是一个固定长度的，包含了相同类型数据的 容器
1、声明数组
// 声明一个数组，并没有创建数组。
int[] a;
[]表示该变量是一个数组
int表示数组里的每一个元素都是一个整数
a是变量名
2、创建数组
创建数组时，要指明数组的长度。
new int[5]
引用概念：
如果变量代表一个数组，比如a,我们把a叫做引用
与基本类型不同
int c = 5; 这叫给c赋值为5
声明一个引用 int[] a;
a = new int[5];
让a这个引用，指向数组
3、访问数组
用下标访问，从0开始
4、数组长度
.length
数组的长度是不可变的，一旦分配好，就不能改变

继承extends
public class Weapon extends Item

通过一个类创建一个对象，这个过程叫做实例化
实例化是通过调用构造方法(又叫做构造器)实现的

this这个关键字，相当于普通话里的“我”
this即代表当前对象
通过this关键字访问对象的属性
如果要在一个构造方法中，调用另一个构造方法，可以使用this()

数字与字符串
1.1、封装类
所有的基本类型，都有对应的类类型
比如int对应的类是Integer
这种类就叫做封装类
1.2、Number类
数字封装类有
Byte，Short，Integer，Long，Float，Double
这些类都是抽象类Number的子类
基本类型转封装类
package digit;

public class TestNumber {

public static void main(String[] args) {
    int i = 5;

    //基本类型转换成封装类型
    Integer it = new Integer(i);
     
}

}
封装类转基本类型
package digit;

public class TestNumber {

public static void main(String[] args) {
    int i = 5;

    //基本类型转换成封装类型
    Integer it = new Integer(i);
     
    //封装类型转换成基本类型
    int i2 = it.intValue();//
     
}

}
自动装箱
不需要调用构造方法，通过=符号自动把 基本类型 转换为 类类型 就叫装箱
如 Integer it = i;
自动拆箱
不需要调用Integer的intValue方法，通过=就自动转换成int类型，就叫拆箱
int i=it；

2、字符串转换
2、1数字转字符串
方法1： 使用String类的静态方法valueOf
方法2： 先把基本类型装箱为对象，然后调用对象的toString

//方法1
        String str = String.valueOf(i);
        //方法2
        Integer it = i;
        String str2 = it.toString();

2.2、字符串转数字
调用Integer的静态方法parseInt

 int i= Integer.parseInt(str);

Math.round() 四舍五入
Math.random() 随机数
Math.sqrt() 开方
Math.pow() 次方
Math.PI() π
Math.E() 自然常数

进行字符串连接，如果变量比较多，拼接就会显得繁琐，使用格式化输出，就可以简洁明了，其中%s 表示字符串、%d 表示数字、%n 表示换行

Character常用方法：
character.isLetter() 判断是否为字母
Character.isDigit() 判断是否为数字
Character.isWhitespace() 是否是空白
Character.isUpperCase() 是否是大写
Character.isLowerCase() 是否是小写
Character.toUpperCase() 转换为大写
Character.toLowerCase() 转换为小写
Character.toString() 转换为字符串

3、字符串
字符串即字符的组合，在Java中，字符串是一个类，所以我们见到的字符串都是对象
常见创建字符串手段：

1. 每当有一个字面值出现的时候，虚拟机就会创建一个字符串
2. 调用String的构造方法创建一个字符串对象
3. 通过+加号进行字符串拼接也会创建新的字符串对象

String 被修饰为final,所以是不能被继承的
immutable 是指不可改变的
比如创建了一个字符串对象
String garen =“盖伦”;
不可改变的具体含义是指：
不能增加长度
不能减少长度
不能插入字符
不能删除字符
不能修改字符
一旦创建好这个字符串，里面的内容 永远 不能改变

length方法返回当前字符串的长度
可以有长度为0的字符串,即空字符串

4、操纵字符串
charAt(int index)获取指定位置的字符

 String sentence = "盖伦,在进行了连续8次击杀后,获得了 超神 的称号";
 char c = sentence.charAt(0);

toCharArray()
获取对应的字符数组

String sentence = "盖伦,在进行了连续8次击杀后,获得了超神 的称号";
char[] cs = sentence.toCharArray(); //获取对应的字符数组

subString
截取子字符串

 String sentence = "盖伦,在进行了连续8次击杀后,获得了 超神 的称号";
         
        //截取从第3个开始的字符串 （基0）
String subString1 = sentence.substring(3);
        //左闭右开
String subString2 = sentence.substring(3,5);

split
根据分隔符进行分隔

 String sentence = "盖伦,在进行了连续8次击杀后,获得了 超神 的称号";
         
        //根据,进行分割，得到3个子字符串
 String subSentences[] = sentence.split(",");

trim
去掉首尾空格

String sentence = "        盖伦,在进行了连续8次击杀后,获得了 超神 的称号      ";
         
  System.out.println(sentence);
        //去掉首尾空格
  System.out.println(sentence.trim());

toLowerCase 全部变成小写
toUpperCase 全部变成大写

indexOf 判断字符或者子字符串出现的位置
contains 是否包含子字符串

String sentence = "盖伦,在进行了连续8次击杀后,获得了超神 的称号";
System.out.println(sentence.indexOf('8')); //字符第一次出现的位置
         
System.out.println(sentence.indexOf("超神")); //字符串第一次出现的位置

System.out.println(sentence.lastIndexOf("了")); //字符串最后出现的位置  

System.out.println(sentence.indexOf(',',5)); //从位置5开始，出现的第一次,的位置                              
          
 System.out.println(sentence.contains("击杀")); //是否包含字符串"击杀"

replaceAll 替换所有的
replaceFirst 只替换第一个

   String sentence = "盖伦,在进行了连续8次击杀后,获得了超神 的称号";
 
        String temp = sentence.replaceAll("击杀", "被击杀"); //替换所有的，后面的替换前面的内容
         
        temp = temp.replaceAll("超神", "超鬼");
         
        System.out.println(temp);
         
        temp = sentence.replaceFirst(",","");//只替换第一个
   

使用equals进行字符串内容的比较，必须大小写一致
equalsIgnoreCase，忽略大小写判断内容是否一致

startsWith //以…开始
endsWith //以…结束

StringBuffer
StringBuffer是可变长的字符串
append追加
delete 删除
insert 插入
reverse 反转

Java的Date
java.util.Date;
1970年时间原点，因为1969年发布了第一个 UNIX 版本：AT&T，综合考虑，当时就把1970年当做了时间原点。
getTime() 得到一个long型的整数
这个整数代表 从1970.1.1 08:00:00:000 开始 每经历一毫秒，增加1

SimpleDateFormat 日期格式化类

日期转字符串
y 代表年
M 代表月
d 代表日
H 代表24进制的小时
h 代表12进制的小时
m 代表分钟
s 代表秒
S 代表毫秒

 //y 代表年
        //M 代表月
        //d 代表日
        //H 代表24进制的小时
        //h 代表12进制的小时
        //m 代表分钟
        //s 代表秒
        //S 代表毫秒
        SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS" );
        Date d= new Date();
        String str = sdf.format(d);
        System.out.println("当前时间通过 yyyy-MM-dd HH:mm:ss SSS 格式化后的输出: "+str);

模式（yyyy/MM/dd HH:mm:ss）需要和字符串格式保持一致，如果不一样就会抛出解析异常ParseException

6、Calendar类
即日历类，常用于进行“翻日历”，比如下个月的今天是多久（不甚了解）
6.1、Calendar与Date进行转换

 //采用单例模式获取日历对象Calendar.getInstance();
        Calendar c = Calendar.getInstance();
          
        //通过日历对象得到日期对象
        Date d = c.getTime();
  
        Date d2 = new Date(0);
        c.setTime(d2); //把这个日历，调成日期 : 1970.1.1 08:00:00

6.2、翻日历
add方法，在原日期上增加年/月/日
set方法，直接设置年/月/日

private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        Date now = c.getTime();
        // 当前日期
        System.out.println("当前日期：\t" + format(c.getTime()));
 
        // 下个月的今天
        c.setTime(now);
        c.add(Calendar.MONTH, 1);
        System.out.println("下个月的今天:\t" +format(c.getTime()));
 
        // 去年的今天
        c.setTime(now);
        c.add(Calendar.YEAR, -1);
        System.out.println("去年的今天:\t" +format(c.getTime()));
 
        // 上个月的第三天
        c.setTime(now);
        c.add(Calendar.MONTH, -1);
        c.set(Calendar.DATE, 3);
        System.out.println("上个月的第三天:\t" +format(c.getTime()));