Java基础知识大概总结

潦草的总结

1、第一个程序

1、代码示例

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello World!");
    }
}

2、注释

1、单行注释：//
2、多行注释：/* */

2、初识类

1、一个java源文件中可以定义多个class类。

2、在java源文件中只要有一个class的定义，必然会对应生成一个class的文件。

3、public修饰的类不是必须的，可以没有。

4、public修饰的类如果有的话，public修饰的类名必须和源文件的文件名一致。

5、一个java源文件只能有一个public修饰的类。

6、示例代码

public class Test{
    public static void main(String[] args){
        System.out.println("Test");
    }
}
class Test2{
    
}
class Test3{
    
}

3、标识符和关键字

1、标识符：凡是程序员可以自己命名的单词都是标识符。

2、标识符的命名规则：

1. 标识符必须有字母(包括中文)、数字、下划线(_)、美元符号($)组成，不能含有其他符号。
2. 标识符不能以数字开头。
3. 标识符不能是关键字或保留字。
4. 标识符严格区分大小写。
5. 标识符理论上没有长度限制。

3、标识符的命名规范：

1. 接口名和类名首字母大写，后面每个单词的首字母大写，遵循驼峰命名规则。
2. 变量名和方法名首字母小写，后面每个单词的首字母小写，遵循驼峰命名规则。
3. 常量名的所有字母全部大写，多个单词之间使用下划线连接(_)。
4. 见名知意。

4、变量

1、变量：变量是内存中存储数据的最基本的单元，可以看作是一个存储数据的盒子。

2、变量的声明赋值：数据类型 变量名 = 变量值

3、变量可以重新赋值。

4、变量的分类：在类体内、方法体外声明的变量是成员变量，在方法体内声明的变量是局部变量，局部变量只在当前方法中有效，方法执行完毕之后该变量会被释放。

5、示例代码：

package test;

public class Test {
    public static void main(String[] args) {
        String name = "张三"; //String类型的变量
        int age = 18; //int类型的变量
        System.out.println(name + "今年" + age + "岁"); //访问变量
    }
}

5、数据类型

1、java中的数据类型

数据类型	占用字节数
byte	1
short	2
int	4
long	8
float	4
double	8
boolean	1
char	2

2、int

public class Test {
    public static void main(String[] args) {
        //在java语言中，整数类型字面量有4种表示形式：二进制、八进制、十进制、十六进制
        int a = 0b10; //二进制
        System.out.println(a); //2
        int b = 010; //八进制
        System.out.println(b); //8
        int c = 10; //十进制
        System.out.println(c); //10
        int d = 0x10; //十六进制
        System.out.println(d); //16
    }
}

public class Test {
    public static void main(String[] args) {
        /*在java语言中，整型字面量默认被当做int类型处理，
          如果希望字面量被当做long来处理，需要在字面量后面
          加上l/L，建议大写L，小写l和1傻傻分不清
         */
        int a = 100;
        System.out.println(a);

        long b = 200; //存在自动类型转换，小容量自动转换为大容量
        System.out.println(b);

        long c = 300L; //不存在自动类型转换
        System.out.println(c);

        long d = 2147483647; //正确，int类型最大值是2147483647
        System.out.println(d);

        /*错误，编译器先将2147483648看作是int类型的数值，
          而2147483648超出了int类型的最大值，所以在没有赋值之前就已经报错了

        long e = 2147483648; //Error:(24, 18) java: 整数太大
        System.out.println(e);
        */

        long f = 2147483648L; //正确
        System.out.println(f);
    }
}

3、自动类型转换：小容量自动转换为大容量

byte-->short-->int-->long-->float-->double
char-->int-->float-->double

4、强制类型转换：数据类型 变量名 = (数据类型) 变量名，存在精度损失

public class Test {
    public static void main(String[] args) {
        long x = 100L;
        System.out.println(x);
        long y = (int)x;
        System.out.println(y);
    }
}

5、当一个整型字面量的值没有超出byte/short的取值范围的时候，这个字面量可以直接赋值给byte/short类型的变量。

public class Test {
    public static void main(String[] args) {
        byte a = 127; //正确
        System.out.println(a);
        /*
        Error:(7, 18) java: 不兼容的类型: 从int转换到byte可能会有损失
        byte b = 128; 
        System.out.println(b);
         */

        short x = 32767; //正确
        System.out.println(x);
        /*
        Error:(12, 19) java: 不兼容的类型: 从int转换到short可能会有损失
        short y = 32768; 
        System.out.println(y);
         */
    }
}

6、计算机在任何情况下都只能识别二进制，计算机在底层存储数据的时候，一律存储的是二进制的补码形式。正数的原码、反码、补码一样，负数的反码是原码符号位不变，其余位按位取反，补码是反码加一。

public class Test {
    public static void main(String[] args) {
        /*
        对于一个正数来说：二进制原码、反码、补码是同一个，完全相同
            int i = 1;
			对应的二进制原码：00000000 00000000 00000000 00000001
			对应的二进制反码：00000000 00000000 00000000 00000001
			对应的二进制补码：00000000 00000000 00000000 00000001
		对于一个负数来说：反码是原码符号位不变，其余位按位取反，补码是反码加一
			byte i = -1;
			对应的二进制原码：10000001
			对应的二进制反码（符号位不变，其它位取反）：11111110
			对应的二进制补码（反码+1）：11111111
         */

        byte b = (byte)150;
        System.out.println(b); //-106
    }
}

public class Test {
    public static void main(String[] args) {
        //byte、short、char做混合运算时，各自先转换为int类型再运算
        char c = 'a';
        byte b = 1;
        System.out.println(c + b); //98

        /*
        Error:(14, 21) java: 不兼容的类型: 从int转换到short可能会有损失
        short s = c + b;
        short s = (short)c + b;
        编译器不知道这个加法的最终结果是多少，只知道是int类型的
         */
        short s = (short)(c + b);

        /*
        Error:(19, 19) java: 不兼容的类型: 从int转换到short可能会有损失
        int a = 1;
        short x = a;
        编译器只知道a是int类型的，并不知道a中存放的值是多少
         */
    }
}

7、浮点型数据：默认数据类型是double

public class Test {
    public static void main(String[] args) {
        //Error:(5, 19) java: 不兼容的类型: 从double转换到float可能会有损失
        //float f = 100.47;
        float f = 100.47F; //正确
        //float f = 100.47f; //正确
        //float f = (float)100.47; //正确
        System.out.println(f);

    }
}

8、boolean类型只有两个值：true和false，不参与类型转换

9、char：用单引号引起来的单个字符

6、运算符

1、从键盘输入

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        //接收一个整数
        int num = s.nextInt();
        System.out.println("输入的整数是：" + num);
        //接收一个字符串
        String str = s.next();
        System.out.println("接收的字符串是：" + str);

    }
}

2、算术运算符

算术运算符	说明
+	加
-	减
*	乘
/	除
%	取余
i++	i先运算，然后i的值自加1
++i	i的值先自加1，再运算
i–	i先运算，然后i的值自减1
–i	i的值先自减1，再运算

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        int x = 10;
        int y = x++;
        System.out.println("x="+x+",y="+y); //x=11,y=10
        int z = ++x;
        System.out.println("x="+x+",z="+z); //x=12,z=12

        int i = 10;
        int j = i--;
        System.out.println("i="+i+",j="+j); //i=9,j=10
        int k = --i;
        System.out.println("i="+i+",k="+k); //i=8,k=8
    }
}

3、关系运算符

关系运算符	说明
>	大于
>=	大于等于
<	小于
<=	小于等于
==	大于
!=	不等于
注：=	赋值运算符

4、逻辑运算符

逻辑运算符	说明
&	逻辑与
|	逻辑或
!	逻辑非
&&	短路与
||	短路或

短路与&&和逻辑与&的区别：首先这两个运算符的运算结果没有任何区别，完全相同。只不过“短路与&&”会发生短路现象。即当左边的表达式值为false的时候，右边表达式不执行，这种现象叫做短路现象。从效率方面来说，&&比&的效率高一些。因为逻辑与&不管第一个表达式结果是什么，第二个表达式一定会执行。
短路或||和逻辑或|的区别与上同理。

5、赋值运算符

赋值运算符	说明
=
+=
-=
/=
*=
%=

public class Test {
    public static void main(String[] args) {
        //使用扩展运算符，永远不会改变表达式的运算结果
        byte b = 100;
        //b = b + 20;//Error:(9, 15) java: 不兼容的类型: 从int转换到byte可能会有损失
        b += 20; //正确，相当于b = (byte)(b+20);
        System.out.println(b); //120

        byte c = 127;
        c += 1;
        System.out.println(c); //-128,byte类型
    }
}

6、三目运算符

public class Test {
    public static void main(String[] args) {
        /*
        三目运算符：布尔表达式？表达式1：表达式2
        执行原理：
			布尔表达式的结果为true时，表达式1的执行结果作为整个表达式的结果。
			布尔表达式的结果为false时，表达式2的执行结果作为整个表达式的结果。
        */
        int a = 10;
        String str = a>0 ? "a是正数" : "a是负数";
        System.out.println(str); //a是正数
    }
}