Java语言基础

前言

尽管学习Java有一段时间了，但是俗话说的好：温故而知新。如果长时间不使用，有的东西可能会遗忘，毕竟人的瞬时记忆居多。所以，想把以前学的东西作一个总结，然后到不记得的时候，回头去看看。从Java语言基础开始，虽然现在看来觉得很简单，但是注意每一个简单的细节是一个合格程序员应该具有的品质。废话不多说。

1、Java基础语法

Java程序的基本组成单元是类，类体中又包括属性和方法。每一个应用程序都必须包含一个主方法，也就是main()方法，含有main方法的类称为主类。如下：

package com.ycz.base;

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

}

1.1、类的定义

类的定义语法如下：

访问修饰符 class 类名{
…
}
访问修饰符不一定是public，可以是其他的，如private等。关键字class是必须的，类名首字母大写，且类名应是有意义的名词，让人一看就知道这个类实例是关于什么的。大括号是类体，里面是代码。比如上面定义的demo类。

1.2、包的声明

package为包的关键字，也就是声明这个类所在的包。

上面的例子，demo类在com.ycz.base包下，其实包就相当于文件夹，包名对应着磁盘下的一个路径，定义的类就存放在这个路径下。

1.3、main方法

main方法是程序的入口，只有唯一的一种写法：

    public static void main(String[] args) {
        
    }

static表示这是个静态方法，void表示此方法不返回任何值，main是方法名，小括号里的是参数，String表示参数类型，[]表示数组符号，args是局部变量名。

1.4、注释

Java中的注释有3种：单行注释、多行注释、文档注释。被注释了的代码是不会被编译和执行的。

单行注释

也就是只对一行代码进行注释。格式为//.....如下：

注释既可以用来去掉不想要的代码，也可以作为说明。

多行注释

可以注释多行代码，格式为/*.....*/，如下：

文档注释

一般写在类或方法的上面，对其进行说明，格式为/**······*/,如下：

注释的作用就两种：屏蔽不需要的代码和作出说明。

1.5、标识符和关键字

标识符

标识符是由由程序员自行定义，在源码中代表某种含义的符号，需符合有关规定，标识符只能由如下4种符号组成（Java、C语言等高级语言都相通）：

• A-Z或a-z（可以使用中文，但不建议，因为源码全是英文，而且使用中文可能存在编码格式问题）。
• _下划线，通常用来连接，如表示常量，MAX_VALUE。
• 0-9的数字，但是不能作为前缀（即不能以数字开头）。
• $美元符号（不建议使用，会与某些特殊类别弄混）。

Java中的标识符主要涉及到类名、变量名、常量名、方法名，如下说明：

• 类名标识符首字母大写，多个单词时每个都首字母大写，其他小写，这是著名的帕斯卡命名法。
• 变量名首字母小写，多个单词时，第一个首字母小写，从第二个开始首字母大写，其他小写，这是驼峰命名法。
• 方法名标识符规则与变量一样。
• 常量名标识符全部大写，多个单词时，中间用下划线_连接。

关键字

关键字是某种语言中代表特殊含义的预定义符号，不能自定义关键字，关键字已默认，或许会更新。但人为无法操作。

注意一点即可，标识符不能用关键字代替，关键字大概53个，如：public、private、void、return、int、double、char、Sting等。

1.6、变量和常量

变量

变量是源程序中对内存数据进行存取的引用符号，变量名称符合标识符命名规则。

int age = 25;

这里的age就是变量，注意：变量要声明后使用，因为Java是强类型语言，不同于JS，绝对不允许使用未定义的变量。

区分成员变量和局部变量

成员变量是在类体中声明的变量，作用域是整个类，而局部变量是在方法内定义的变量，只在方法内起作用，方法外无效，如下：

public class Test {
    
    private String name;
    
    private String sex;
    
    private int age;

    public Test(String name) {
        this.name = name;
    }
    
    public void showMe() {
        String address = "China";
    }

}

name、sex、age都是成员变量，或者叫全局变量，而address是局部变量。当局部变量和成员变量重名时，用this关键字指向成员变量，上面的构造方法。

常量

常量可以理解为不可变的变量，常量不能修改，是只读的，有普通常量和标志性常量。

普通常量：比如2、6.5、"me"等。
标志性常量：使用final修饰符修饰的，如下：

public final static int MAX_AGE = 18;

这里的MAX_AGE就是一个比较标准的常量了。

1.7、基本数据类型

Java中的数据类型其实有两种：基本数据类型和引用数据类型。这里只说基本数据类型。基本数据类型分为4型8种，如下：

整型：byte 、short 、int 、long。
浮点型：float 、 double。
字符型：char。
布尔型：boolean。

byte：字节类型，关键字byte，内存中占1个字节，8位，1byte=8bits，1字节为8比特，范围-128-127。

short：短整型，关键字short，内存中占2个字节，2字节即16比特位，范围-32768-32767。

int：系统默认的数据类型，不作说明，则作为int类型处理，内存占4个字节，即32比特位，范围-2147483648-2147483647。

long：长整型，关键字long，内存占8个字节，即64比特位，范围过大。要正确定义，如：long a = 3025344545L，不这样定义则会默认为int型，要注意。

float：关键字float，占4个字节，即32比特位。正确命名：float b = 156.3F，否则会默认为double类型。

double：关键字double,占8个字节，64比特位。系统默认的浮点型为double，即把不作说明的浮点类型数据自动当做double类型处理。

char：，占2个字节，16比特位，char类型可存储单个字符，多个字符要用String。char与int是兼容的，要注意。

boolean：占1个字节，8比特位，表示真与假、是与否等，用于逻辑判断。返回值只有true和false。

注意int和char是兼容的，可用char类型接收int型数据，但不能超出其存储范围，如下：
char ch = ‘a’;
ch=78;
这是允许的。

数据类型的转换

有自然转换和强制转换两种。自然转换即低精度向高精度转换，强制转换用于高精度向低精度转换。

public class demo {

    public static void main(String[] args) {
        byte by = 23;
        short sh = 3423;
        int a = 334343433;
        //自然转换，低精度向高精度
        int b = sh;
        long lo = 343443454444l;
        float f1 = 343.434f;
        double dou = 2312333.32;
        //强制转换，高精度向低精度
        float f2 = (float)dou;
        char ch = 'y';
        boolean bool = false;
        //测试int和char的转换
        char cha = (char)a;
        int ych = (int)ch;
        //int和char在一定范围内是兼容的，也就是在char表示的范围内
        char ch2 = 35;
        int a2 = 'h';
        System.out.println("333对应的字符是：" + cha);
        System.out.println("字符y的ASCII码是：" + ych);
        System.out.println("byte类型的范围是：" + Byte.MIN_VALUE + "--" + Byte.MAX_VALUE);
        System.out.println("short类型的范围是：" + Short.MIN_VALUE + "--" + Short.MAX_VALUE);
        System.out.println("int类型的范围是：" + Integer.MIN_VALUE + "--" + Integer.MAX_VALUE);
        System.out.println("long类型的范围是：" + Long.MIN_VALUE + "--" + Long.MAX_VALUE);
        System.out.println("float类型的范围是：" + Float.MIN_VALUE + "--" + Float.MAX_VALUE);
        System.out.println("double类型的范围是：" + Double.MIN_VALUE + "--" + Double.MAX_VALUE);
        System.out.println("boolean类型的范围是：" + Boolean.FALSE + "--" + Boolean.TRUE);
    }

}

以上8种基本型数据，如果定义成静态的，是有默认值的，如下：

public class Test {

    private static byte b;
    private static short s;
    private static int i;
    private static long l;
    private static float f;
    private static double d;
    private static char c;
    private static boolean bo;

    public static void main(String[] args) {
        System.out.println("静态byte型默认值：" + b);
        System.out.println("静态short型默认值：" + s);
        System.out.println("静态int型默认值：" + i);
        System.out.println("静态long型默认值：" + l);
        System.out.println("静态float型默认值：" + f);
        System.out.println("静态double型默认值：" + d);
        System.out.println("静态char型默认值：" + (int) c);
        System.out.println("静态boolean型默认值：" + bo);
    }

}

执行，控制台：

关于ASCII码表：

American Standard Code for Information Interchage，美国信息交换标准码，是一套基于电脑的编码系统，使用7位或8位二进制数组合来表示128或256中可能的字符，记住特殊字符码值即可，如：码值32表示空格space、码值65-90表示大写字母A-Z（因为包含65自身，所以最大值为65+26-1即为90）、码值97-122表示小写字母a-z。

关于原码、反码、补码：(以8位二进制为例）

正数：如十进制10,10=8+2，二进制为1010，正数符号位为0，其余3位为以0补齐（补齐8位二进制），即10的二进制为00001010，即为原码，正数的补码反码与原码相同。
负数：如-10，符号为最高位，负数符号位为1，其余以0补齐，-10的原码为10001010，反码是符号位不变，其余位以1换0，以0换1，即反码为11110101，补码是反码加1，即为11110110。

二进制、八进制、十进制、十六进制转换
各进制准换为10进制，可按基数与位权值相乘展开相加即可，十进制转为n进制可按商除法（除以n），二进制转成八进制可按3位二进制数对应1位八进制数进行简便转换，同理，二进制转十六进制可按4位二进制数对应1位16进制数进行准换，十六进制、八进制转为二进制可反向，八进制、十六进制之间的相互转换可通过中间过渡为二进制数，间接简便转换。

1.8、运算符

包括赋值运算符、算术运算符、关系运算符、逻辑运算符、位运算符与特殊运算符。

赋值运算符

将一个数据（常量或变量）赋值给另一个变量，最常见的=，右边赋给左边，复合运算符+=、-=、*=、/-、%=。

        int a = 10;
        a += 10;//相当于a=a+10
        System.out.println("a======>" + a);
        a -=10;//相当于a=a-10
        System.out.println("a======>" + a);
        a /= 10;//相当于a=a/10
        System.out.println("a======>" + a);
        a %=10;//相当于a=a%10
        System.out.println("a======>" + a);  

算数运算符

对几个数据进行计算，如+、-、*、/、%、++（自增）、- -（自减）。顺序为从左向右执行。
特殊的为自增自减运算，属于单目运算，而其他4个属于双目运算符。如num = ++i，表示i加1后，再赋值给num，而num = i++则表示先把i值赋给num后，再执行加1，特别注意的是自增自减运算符只能用于变量，如6++是错误的形式，注意即可。

        int a = 10;
        int b = 5;
        System.out.println("a+b=" + (a + b));
        System.out.println("a-b=" + (a - b));
        System.out.println("a*b=" + (a * b));
        System.out.println("a/b=" + (a / b));
        System.out.println("a%b=" + (a % b));
        int c = a++;// 先赋值再自增
        System.out.println("c=" + c);
        int d = --b;// 先自减再赋值
        System.out.println("d=" + d);

关系运算符

进行比较并得出布尔boolean结果，如>、<、>=、<=、==（等于）、!=（不等于）。

        int a = 10;
        int b = 5;
        boolean bool = a > b;
        boolean bool2 = a < b;
        boolean bool3 = a == b;
        boolean bool4 = a != b;
        System.out.println("a>b成立吗？" + bool);
        System.out.println("a<b成立吗？" + bool2);
        System.out.println("a=b成立吗？" + bool3);
        System.out.println("a!=b成立吗？" + bool4);

逻辑运算符

用来连接布尔boolean变量、常量或关系表达式计算得到boolean结果。有&&、||、！。
&&（与）：true&&true才为true,其他为false。注意短路逻辑，如第一个为false，则后面的不执行，直接判定结果为false。
||（或）：有一个true结果就为true,注意短路逻辑，第一个为true，则后面的不执行，直接判定结果为true。
!（非）：!true为false，!false为true，boolean结果取反即可。

        int a = 10;
        int b = 5;
        int c = 20;
        boolean bool = a > b && b>c;
        boolean bool2 = a > b || b>c;
        boolean bool3 = !(a > b && b>c);
        System.out.println("a>b和b>c都成立吗？" + bool);
        System.out.println("a>b或者b>c成立吗？" + bool2);
        System.out.println("a>b和b>c不是都成立的？" + bool3);

位运算符

将数据在内存中二进制数按位运算，得出结果，4种，&、|、~、^。
&：按位与，对整型和布尔计算，如5&8,5的二进制为101，8的二进制为1000,0101&1000=0000，转换十进制为0，即5&8=0，对于布尔，类似逻辑与，true&true为true，其他为false。
|：按位或，对整型和布尔计算，如5|8，0101|1000=1101，转换十进制为13，对于布尔，有一个为true结果就为true，类似逻辑或。
~ ：按位非，只对整型计算，按位取反。
^ ：按位异或，对整型和布尔，对于布尔，相同为false，相异为true，对于整型，相同为0，相异为1，如5 ^ 8,0101^1000=1101，结果为13。

        int a = 8;
        int b = 5;
        int c = 20;
        System.out.println("a & b = " + (a & b));
        System.out.println("a > b & a > c的结果为： " + (a > b & a > c));
        System.out.println("a | b = " + (a | b));
        System.out.println("a > b | a > c的结果为： " + (a > b | a > c));
        System.out.println("~ 5 = " + (~b));
        System.out.println("a ^ b = " + (a ^ b));
        System.out.println("a > b ^ a > c的结果为： " + (a > b ^ a > c));

特殊运算符

包括移位运算符及new、()、[]等。
移位运算符有<<、>>、>>>3种。
<<为左移运算符，弃最高位，0补低位，如int n = 5,m=n<<2,5的二进制为110，左移2位为11000，即为24，如果移动的位数超过了该类型的最大位数，则对移动位数先取模，如int n = 5,m=n<<35，对35先取模，35%32=3，那么等价于int n = 5,m=n<<3，注意即可。
>> 为右移运算符，符号位不变，左边补上符号位，空位补0。
>>>为无符号右移运算符，只对正数，0补高位，类似于>>。
new运算符用于创建某个引用数据类型的对象，如Student stu = new Student(),实例化创建Student对象。
.通常用于对某个对象的属性或方调引用，如stu.showMe()，stu.name。
()优先运算，[]通常用于数组中，数组类型数据的标志。
instanceof表示判断某对象或引用是否属于某种类型。

        int b = 5;
        System.out.println("b<<2=" + (b << 2));
        System.out.println("b<<34=" + (b << 34));
        System.out.println("b>>2=" + (b >> 2));
        System.out.println("b>>>2=" + (b >>> 2));
        String s = "1dd1";
        System.out.println("s属于String类型吗？" + s instanceof String);

1.9、转义字符

转移字符对应的英文是escape character , 转义字符串（Escape Sequence）。
字母前面加上捺斜线""来表示常见的那些不能显示的ASCII字符.称为转义字符.如\0,\t,\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了。常见的如下：

2、流程控制

2.1、if条件表达式

常见的有几种：

if(布尔表达式){
代码
}

布尔表达式为true时才执行括号体里面的内容，否则直接跳过。

if(布尔表达式){
语句1
}else{
语句2
}

如果布尔表达式为true，执行语句1，否则执行语句2。

if(布尔表达式1）{
语句1
}else if(布尔表达式2){
语句2
} else if(布尔表达式3）{
语句3
} else{
语句4
}

布尔表达式1为true，执行语句1，否则继续判断布尔表达式2，为true执行语句2，否则继续往下判断，缺点是结构不够明显，过于冗杂。

        String status = "single";
        int age = 25;
        int score = 93;
        if (status.equals("single")) {
            System.out.println("目前单身！");
        }
        if (age < 18) {
            System.out.println("还未成年！");
        } else {
            System.out.println("一大把年纪！");
        }
        if (score < 60) {
            System.out.println("没及格！");
        } else if (score < 80) {
            System.out.println("成绩一般！");
        } else if(score < 90) {
            System.out.println("成绩优秀！");
        } else if (score <= 100) {
            System.out.println("成绩非常好！");
        } else {
            System.out.println("爆表了！");
        }
    }

2.2、条件表达式（三目运算符）

布尔表达式1?表达式2:表达式3；

布尔表达式1为true时，执行表达式2，否则执行表达式3，用三目运算符可以代替简单的if···else语句，更加简洁。

        // if (age < 18) {
        // System.out.println("还未成年！");
        // } else {
        // System.out.println("一大把年纪！");
        // }
        String s = age < 18 ? "还未成年！" : "一大把年纪！";

2.3、switch多分支条件语句

switch(开关表达式){
case 常量表达式1：
语句1；
break；
case 常量表达式2：
语句2；
break；
case 常量表达式3：
语句3；
break；
default:语句4；
}

需要说明的是常量表达式不一定是数字，是常量即可，可以是字符，可以是表达式，但表达式结果要为数字，这样的逐级判断执行结构清晰，一目了然，break用于跳出switch语句，所有基本上都是switch···break连用。

        String day = "星期日";
        switch (day) {
        case "星期一":
            System.out.println("今天是星期一！");
            break;
        case "星期二":
            System.out.println("今天是星期二！");
            break;
        case "星期三":
            System.out.println("今天是星期三！");
            break;
        case "星期四":
            System.out.println("今天是星期四！");
            break;
        case "星期五":
            System.out.println("今天是星期五！");
            break;
        case "星期六":
            System.out.println("今天是星期六！");
            break;
        default:
            System.out.println("今天是星期天，终于不用上班！");
            break;
        }

2.4、while循环语句

有两种形式：

while(布尔表达式){
语句1；
}

布尔表达式为true时，执行语句1，执行完后，继续回到布尔表达式判断，为true时继续执行语句1，一直到不满足布尔表达式跳出循环，所以while循环可能一次都不执行循环体。

do{
语句1;
}while(布尔表达式);

先执行一次语句1，然后判断布尔表达式，为true时继续执行语句1，执行完后继续判断，一直到不满足布尔表达式时跳出循环，也就是说，区别于while循环，do···while循环至少执行一次循环体。

        int i = 1;
        int sum = 0;
        while (i <= 100) {
            sum += i;
            i++;
        }
        System.out.println("1到100的和为：" + sum);

        int i = 1;
        int sum = 0;
        do {
            sum += i;
            i++;
        } while (i <= 100);
        System.out.println("1到100的和为：" + sum);
    }

2.5、for循环

for循环一般就这两种用法：

for(表达式1；布尔表达式2；表达式3){
循环体语句；
}

for(类型 变量:数组或集合){
......
}

        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println("1到100的和为：" + sum);
    }

        Integer[] arr = {1, 3, 4, 12, 43, 31 };
        List<Integer> nums = Arrays.asList(arr);
        for (int i : nums) {
            System.out.println(i);
        }

2.5、break和continue关键字

break用于强制结束语句，直接跳出循环，也可以用于跳出switch分支语句。而continue不同，continue是结束本次循环，继续进入下一次循环，而不是跳出整个循环体。一般是用这两个关键字来进行循环控制的。

        Integer[] arr = {1, 3, 4, 12, 43, 31 };
        List<Integer> nums = Arrays.asList(arr);
        for (int i : nums) {
            if(i==4) {
                continue;
            }
            System.out.println(i);
        }

i=4是直接跳过去了。

跳出外层循环

可以使用break或continue来跳出最外层循环，借助一个标签即可。

标签名：循环体{
    break 标签名;
}

这样就可以使用break跳出指定标签处的循环，可以是内层循环，也可以是外层循环，内存循环的话没必要使用标签。

        label0: for (int i = 1; i <= 10; i++) {
            for (int j = 11; j <= 20; j++) {
                if (j % 2 == 0) {
                    break label0;
                }
                System.out.println(i + "====>" + j);
            }
        }

这个只循环一次就直接跳出来了。

类似的，continue也可以结束本次内层循环，跳到外层循环：

标签名：循环体{
    continue 标签名;
}

        label0: for (int i = 1; i <= 3; i++) {
            for (int j = 11; j <= 20; j++) {
                if (j > 15) {
                    continue label0;
                }
                System.out.println(i + "====>" + j);
            }
        }

其实没有必要这么写，直接缩小j的范围就行了。