Java基础

Java基础

前言

JDK JRE JVM

• JDK: java development kit java 环境
• JRE: java Runtime Environment java 运行时环境
• JVM: java virtual Machine java 虚拟机

Java 运行机制

• 编译型
  • 所有的Java代码都是要编译的，.java不经过编译就什么用都没有。
• 解释型
  • java代码编译后不能直接运行，它是解释运行在JVM上的，所以它是解释运行的，那也就算是解释的了。

HelloWorld

public class HelloWorld {
    public static void main(String[] args) {
        String $firstname = "L";
        String _lastname = "Q";
        String age = "1";

        System.out.println("Hello World"+ " "+ $firstname + _lastname + " "+ age );
    }

}

可能遇到的问题

01、注释

1. 单行注释(idea快捷键ctrl+/)
2. 多行注释(idea快捷键ctrl+shift+/)
3. 文档注释

/**
 * Created by Q on 2021/4/17.
 */

public class HelloWorld {
    public static void main(String[] args) {
//单行注释输出hello world
        System.out.println("Hello World");
    }

/*多行注释
多行注释*/

/**
 * @author Q
 * @decription JavaDoc文档注释
 */
}

02、标识符与关键字

2-1 标识符

Java 中标识符是为方法、变量或其他用户定义项所定义的名称。标识符可以有一个或多个字符。在 Java 语言中，标识符的构成规则如下。

标识符由数字（0_{9）和字母（A}Z 和 a~z）、美元符号（$）、下划线（_）以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）。

标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。

另外，Java 区分大小写，因此 name 和 Name 是两个不同的标识符。

注意：标识符命名时，切记不能以数字开头，也不能使用任何 Java 关键字作为标识符，而且不能赋予标识符任何标准的方法名。

标识符分为两类，分别为关键字和用户自定义标识符。

关键字是有特殊含义的标识符，如 true、false 表示逻辑的真假。

用户自定义标识符是由用户按标识符构成规则生成的非保留字的标识符，如 abc 就是一个标识符。注意：使用标识符时一定要注意，或者使用关键字，或者使用自定义的非关键字标识符。此外，标识符可以包含关键字，但不能与关键字重名。

合法与不合法标识符示例。

合法标识符：date、$2021、_date、D_$date 等。

不合法的标识符：1111.com、1com、for、if 等。

标识符用来命名常量、变量、类和类的对象等。因此，在我们命名标识符时，应赋予它一个有意义或有用途的名字。

2-2 关键字

关键字（或者保留字）是对编译器有特殊意义的固定单词，不能在程序中做其他目的使用。关键字具有专门的意义和用途，和自定义的标识符不同，不能当作一般的标识符来使用。

Java 的关键字对 Java 编译器有特殊的意义，它们用来表示一种数据类型，或者表示程序的结构等。

保留字是为 Java 预留的关键字，它们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。

Java 语言目前定义了 51 个关键字，这些关键字不能作为变量名、类名和方法名来使用。以下对这些关键字进行了分类。

数据类型：boolean、int、long、short、byte、float、double、char、class、interface。

流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。

修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。

动作：package、import、throw、throws、extends、implements、this、supper、instanceof、new。

保留字：true、false、null、goto、const。

注意：由于 Java 区分大小写，因此 public 是关键字，而 Public 则不是关键字。但是为了程序的清晰及可读性，要尽量避免使用关键字的其他形式来命名。

03、数据类型

• 强类型语言：Java c++ (先定义后使用)
• 弱类型语言：javascript python

java数据类型

3-1 基本类型（primitive type）

数值类型+布尔类型

• 整数 ：int byte short long
• 小数：float double
• 字符：char
• 布尔型：true false

字符串String是类不是关键字

/**
 * Created by Q on 2021/4/18.
 */
public class Demo01 {
    public static void main(String[] args) {
		//八大基本类型

		//整数
        int num1 = 1000000; //最常用  4字节
        byte num2 = 111; //-128--127 1字节
        short num3 = 11111;  //2字节
        long num4 = 1111111L; //long类型要在数字后加L 8字节

		//小数：浮点数
        float num5 = 1.111F; //float类型要在数字后加F 4字节
        double num6 = 3.14159265358979; //8字节

		//字符
        char aaa = 'a'; //注意单引号不是双引号，2个字节
        //String name = "李四";
        //字符串String是类不是关键字

		//布尔型：是非
        boolean flag = true; //1位

        System.out.println(flag);
    }
}

扩展

/**
 * Created by Q on 2022/1/5.
 */
public class Demo02 {
    public static void main(String[] args) {
        //整数拓展 进制  二进制（0b开头）  十进制   八进制（0开头）  十六进制（0x开头）
        int i1 = 0b10;
        int i2 = 010;
        int i3 = 0x10;

        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("===========================");

        //==================================================
        //浮点数拓展    银行业务表示（钱的计算）
        //BigDecimal   数学工具类（如果需要计算，而且不能让它有误差就使用这个类）
        //最好完全避免使用浮点数进行比较
        //==================================================
        float f = 1.1f;
        double d = 1.1d;
        System.out.println(d == f);    //false
        float f1 = 12544524154441f;
        float f2 = f1 + 1;
        System.out.println(f1 == f2);       //true(精度丢失)
        System.out.println("===========================");

        // 字符扩展
        char c1='a';
        char c2='中';
        //我们通过单引号来表示字符常量
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);
        //强制转换可以把字符转换成数字，所有的字符本质还是数字
        // Unicode 编码表：97=a 65=A  （本质上还是数字）
        // 2字节    65536字符  Excel最长有2的16次方=65536
        //U0000   UFFFF
        char c3='\u0061';
        System.out.println(c3);//a
        //转义字符（转义字符它有特殊的意思）
        // \t    制表符
        // \n    换行
        //  转义字符有非常的多，可以自己去查询一下
        System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");
        System.out.println("===============================");
        String sa = new String("Hello World");
        String sb=new String("Hello World");
        System.out.println(sa==sb);    //false    两个对象是不同的
        String sc = "Hello World";
        String sd="Hello World";
        System.out.println(sc==sd);    //true

        //布尔值扩展
        boolean flag=true;
        if (flag==true){}
        if (flag){}  //省略
    }
}

3-2 引用类型（reference type）

类 接口 数组

3-3类型转换

类型从low———->high次序：

低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double

3-3-1 自动类型转换

自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型。

3-3-2 强制类型转换

强制类型转换，又被称为造型，用于显式的转换一个数值的类型.

隐含强制转换

• 可能的默认类型是int。
• 小数默认是双精度浮点型double，在定义浮点类型时必须在数字下面跟上 F 或者 f。

3-3-3 常见的错误和问题

• 操作比较大的数时，要留意是否溢出，尤其是整数操作时；
• long类型使用大写L不要用小写。

3-3-4 拓展：JDK7扩展

• JDK7新特性: 二进制整数
  JDK7为我们直接提供了二进制整数的类型。
  以0b开头即可。

//例如：int a = 0b0101：

• JDK7新特性：下划线分隔符

//例如：int b = 1_2345_6789;

根据特性，我们能够很容易地知道这是1亿2345万6789。

• 注意点：
  1.不能把布尔值进行转换
  2.不能把对象类型转换为不相干的类型
  3.在把高容量转换到低容量的时候，强制转换
  4.转换的时候可能存在内存溢出，或者精度问题！

/**
 * Created by Q on 2022/1/6.
 */
public class Demo03 {
    public static void main(String[] args) {
		//类型转换
        int i = 128;
        byte b = (byte)i; //内存溢出
		//自动类型转换  低-->高
        System.out.println(i); //128
        System.out.println(b); //-128
		//===================================================

        System.out.println((int)23.7); //23  //精度问题
        System.out.println((int)-45.89f); //-45  //精度问题
        System.out.println("============================");
		//===================================================

        char c = 'a';
        int d = c+1;
        System.out.println(d); //98
        System.out.println((char)d); //b
		//===================================================

		//操作比较大的数，注意溢出
		//JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        System.out.println(money); //1000000000(10 亿） 不会输出下划线
        int years = 20;
        int total = money*years;
        System.out.println(total); //-1474836480 ,计算时内存溢出
        System.out.println("============================");
        long total2 = money*years; //-1474836480 默认是int，转换之前已经存在问题
        long total3 = money*((long)years);//先将一个数转换为long
        System.out.println(total2);   //-1474836480
        System.out.println(total3);   //20000000000
    }
}

04、变量与常量

4-1 变量

变量作用域

• 类变量
• 实例变量
• 局部变量

变量的命名规范

• 所有的变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则（lastName）
• 局部变量：首字母小写和驼峰原则（lastName）
• 常量：大写字母和下划线（MAX_VALUE）
• 类名：首字母大写和驼峰原则(HelloWorld)
• 方法名：首字母小写和驼峰原则

注意点

• 实例变量：从属于对象；可以理解为从属于一个类，如果不自行初始化，就会变成这个类型的默认值。
• 所有的数值类型初始化，一般是0 0.0 u00000
• 布尔值：默认是false
• 除了基本类型，其余的默认值都是null
• 局部变量是在方法里面的；必须声明和初始化值

4-2 常量

• 常量名一般使用大写字符
• final 常量名 = 值;

/**
 * Created by Q on 2022/1/6.
 */
public class Demo04 {
    String name;     // 实例变量
    int age;
    //类变量  static（关键字）从属于类
    static double salary = 2500;   //类变量

    static final double PI = 3.14 ;  //常量
    public static void main(String[] args) {
        int a = 2;   //局部变量
        Demo04 demo04 = new Demo04();

        System.out.println(demo04.name);  //null
        System.out.println(demo04.age);  //0
        System.out.println(demo04.salary);  //2500.0
        System.out.println(a*PI);  //6.28
    }
}

05、运算符

java 语言支持如下运算符

• 算数运算符 :+ ，-， *， /，%, ++ ，—
• 赋值运算符: =
• 关系运算符：>，<, >=,<=,==,!= instanceof
• 逻辑运算符： &&，|| ，！
• 位运算符：&，| ，^, ~ ，>>,<<,>>>
• 条件运算符？：
• 扩展赋值元芳：+=，-=，*=，/=

尊重原创：（口诀）转自http://lasombra.iteye.com/blog/991662
单目乘除位关系，逻辑三目后赋值。

单目：单目运算符+ –(负数) ++ -- 等
乘除：算数单目运算符* / % + -
位：位移单目运算符<< >>
关系：关系单目运算符> < >= <= == !=
逻辑：逻辑单目运算符&& || & | ^
三目：三目单目运算符A > B ? X : Y
后：无意义，仅仅为了凑字数
赋值：赋值=

扩展

package operator;

/**
 * Created by Q on 2022/1/8.
 */
public class Demo05 {
    public static void main(String[] args) {
        //Math 运算工具类
    	System.out.println(Math.pow(2,3));  //8.0
    
        int c = 3;
		//短路运算
        System.out.println(c>5&&c++>10);  //c++>10不执行
        System.out.println(c);  //3
        
		//位运算        
        System.out.println(2<<3);   //左移三位   00010   ===>  10000
        
        //字符串连接符 +
        System.out.println(a+b);
        System.out.println(""+a+b);  //1020  加号两侧出现字符串则转为String进行拼接
        System.out.println(a+b+"");  //30
    }
}

06、包机制与JavaDoc

6-1 包机制（package）

一般利用公司的域名倒置作为包名

package com.baidu.www;   
package com.Q.base;       //package pkg1[. pkg2[. pkg3……]]；

导入包

import package.pkg1.pk.class.*；    //*表示通配符，导入该包全部内容

6-2 JavaDoc

• JavaDoc命令行实现步骤

1. 首先打开cmd命令行窗口 ，切到需要生成文档的Java代码所在文件夹下。
2. 输入JavaDoc命令行，生成HTML文件。javadoc -encoding UTF-8 -charset UTF-8 Doc.java

• IDEL编辑器文档生成步骤

07、Scanner类

通过Scanner 类的next() 和nextLine()方法可获取输入的字符串，读取前，一般使用hasNext() 与hasNextLine()判断是否还有输入。

• next():

  • 一定要读取到有效字符后才可以结束输入。
  • 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
  • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  • next() 不能得到带有空格的字符串。

• nextLine():

  • 以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
  • 可以获得空白。

package com.Q.scanner;

import java.util.Scanner;

/**
 * Created by Q on 2022/1/9.
 */
public class Demo01 {
    public static void main(String[] args) {
		//创建一个扫描器对象用于接收键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据：");   //Hello World!
        if (scanner.hasNext()){
            String str = scanner.next();
            System.out.println("输入的数据为："+str);    //Hello
        }
		//String str = scanner.nextLine();
		//System.out.println("输入的数据为："+str);   //Hello World!

		//凡是I/O类使用完毕记得关闭以节约资源
        scanner.close();
    }
}

扩展：求平均数

package com.Q.scanner;

import java.util.Scanner;

/**
 * Created by Q on 2022/1/9.
 */
public class Demo03 {
    public static void main(String[] args) {
		//算平均数
        double sum = 0;
        int count = 0;
        System.out.println("请输入数据");
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextDouble()){  //输入非double类型即可结束
            double d = scanner.nextDouble();
            count++;
            sum = sum +d;
            System.out.println("当前输入的为第"+count+"个数据为："+d);
        }
        System.out.println("输入的"+count+"个数据的平均数为"+(sum/count));
        scanner.close();
    }
}

08、流程控制

8-1顺序结构

8-2选择结构

if结构 switch结构

JDK7之后，switch语句中的变量类型可以是字符串 比较的value值是 “name.hashCode()”

反编译 java----class(字节码文件)----反编译(IDEA)

• class反编译后的代码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.Q.struct;

public class SwitchDemo01 {
    public SwitchDemo01() {
    }

    public static void main(String[] args) {
        char grade = 65;
        String name = "李";
        switch(grade) {
        case 65:
            System.out.println("成绩优秀");
            break;
        case 66:
            System.out.println("成绩良好");
            break;
        case 67:
            System.out.println("成绩及格");
            break;
        case 68:
            System.out.println("成绩不及格");
            break;
        default:
            System.out.println("输入不合法");
        }

        byte var4 = -1;
        switch(name.hashCode()) {
        case 23376:
            if(name.equals("子")) {
                var4 = 2;
            }
            break;
        case 26408:
            if(name.equals("木")) {
                var4 = 1;
            }
            break;
        case 26446:
            if(name.equals("李")) {
                var4 = 0;
            }
        }

        switch(var4) {
        case 0:
            System.out.println("李");
            break;
        case 1:
            System.out.println("木");
            break;
        case 2:
            System.out.println("子");
            break;
        default:
            System.out.println("未查询到名字");
        }

    }
}

• java原代码

package com.Q.struct;

/**
 * Created by Q on 2022/1/10.
 */
public class SwitchDemo01 {
    public static void main(String[] args) {
        char grade = 'A';
        String name = "李";
        switch (grade) {
            case 'A':
                System.out.println("成绩优秀");
                break;   //不加上case会出现穿透现象
            case 'B':
                System.out.println("成绩良好");
                break;   //不加上case会出现穿透现象
            case 'C':
                System.out.println("成绩及格");
                break;   //不加上case会出现穿透现象
            case 'D':
                System.out.println("成绩不及格");
                break;   //不加上case会出现穿透现象
            default:
                System.out.println("输入不合法");
        }
        switch (name){
            case "李":
                System.out.println("李");
                break;
            case "木":
                System.out.println("木");
                break;
            case "子":
                System.out.println("子");
                break;
            default:
                System.out.println("未查询到名字");
        }
    }
}

8-3循环结构

while循环 do while循环 for循环

小练习1 求0-100奇数和偶数和

package com.Q.struct;

/**
 * Created by Q on 2022/1/10.
 */
public class ForDemo02 {
    public static void main(String[] args) {
        //求0-100奇数和偶数和
        int oddSum = 0;
        int evenSum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i%2!=0){
                oddSum = oddSum +i;
            }else {
                evenSum = evenSum +i;
            }
        }
        System.out.println("奇数和："+oddSum);
        System.out.println("偶数和："+evenSum);
    }
}

小练习2 输出1-1000能被5整除的整数，且每行输出三个

package com.Q.struct;

/**
 * Created by Q on 2022/1/10.
 */
public class ForDemo03 {
    public static void main(String[] args) {
		//输出1-1000能被5整除的整数，且每行输出三个
        for (int i = 1; i <= 1000; i++) {
            if (i%5==0){
                System.out.print(i +"\t");   //水平制表转义字符
            }
            if (i%(5*3)==0){    //注意if (i%5*3==0)错误, % 优先级与 * 同级，从左向右依次运算
//                System.out.println();    //与print区别输出后换行，print输出后不换行
                System.out.print("\n");   //换行转义字符
            }
        }
    }
}

小练习3 输出9*9乘法表

package com.Q.struct;

/**
 * Created by Q on 2022/1/11.
 */
public class ForDemo04 {
    public static void main(String[] args) {
        //9*9乘法表
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

小练习4 打印5*5正三角形

package com.Q.struct;

/**
 * Created by Q on 2022/1/11.
 */
public class TextDemo {
    public static void main(String[] args) {
        //打印5*5正三角形
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            for (int j = 2; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

增强for循环

package com.Q.struct;

/**
 * Created by Q on 2022/1/11.
 */
public class ForDemo05 {
    public static void main(String[] args) {
        int[] numbers = {1,0,2,4};
        for (int i = 0; i < 4; i++) {
            System.out.println(numbers[i]);
        }
        System.out.println("===================");
		//遍历数组或集合
        for (int x:numbers){
            System.out.println(x);
        }
    }
}

8-4Break & Continue

break

package com.Q.struct;

/**
 * Created by Q on 2022/1/11.
 */
public class BreakDemo {
    public static void main(String[] args) {
        int i=0;
        while (i<100){
            i++;
            if (i==30)
                break;  //终止循环
            System.out.println(i);  //输出1-29
        }

    }
}

continue

package com.Q.struct;

/**
 * Created by Q on 2022/1/11.
 */
public class ContinueDemo {
    public static void main(String[] args) {
        int i=0;
        while (i<30){
            i++;
            if (i%10==0){
                System.out.println();
                continue;  //结束本次循环，继续执行下一次循环
            }
            System.out.print(i);
        }
    }
}