关键字和保留字

关键字：被Java定义的字符（数据类型int、流程控制if、访问权限修饰public）

保留字：可能成为关键字的字符

标识符命名规范

字母数字下换线、首不能为数字

包名：所有字母都小写

类名、接口名：首字母大写（大驼峰）

变量名、方法名：先小后大（小驼峰）

常量名：所有字母都大写，多单词用下划线连接

Java采用unicode字符集，可以使用中文

main不是关键字

注释

单行注释：//内容

多行注释：/*内容*/

文档注释：/**内容*/

变量

变量的定义

基本数据类型变量int a，会在虚拟机栈中（存储空间小，但运行速度快）开辟一块空间，通过变量a的名称引用到

int b = 100系统开辟一块空间并赋值，通过变量b的名称引用到

定义格式：数据类型变量名 = 值

赋值方式

定义时初始化赋值

public class 变量 {
    public static void main(String[] args) {
        int a = 100;
        System.out.println(a);
    }
}

//输出100

定义后赋值

public class 变量 {
    public static void main(String[] args) {
        int a = 100;
        int b;
        b = 200;
        System.out.println(a+b);
    }
}

//输出300

变量必须先定义、再赋值后使用（不初始化不可使用，属于编译错误）

变量都定义在作用域内，在作用域内有效

同一个作用域内，不可以声明两个同名变量，不然输出的时候系统会懵的一批

内部代码块可以访问外部代码块的变量，但外部代码块不能访问内部代码块的变量

同时，一个java文件里也不能出现两个同名类，也是一样的道理

public class 变量 {
    public static void main(String[] args) {
        int a = 100;
        int b;
        b = 200;
        System.out.println(a);
    }

    public void method() {
        int a=6000;
        System.out.println(a);
    }
}
//还是输出100，如果a换一个变量名，在主方法中输出，会找不到符号，属于编译错误

常量的声明格式

finnal int a=100;(之后的值不可以被修改)

变量的类型

基本数据类型：

整型：byte \ short \ int \ long

浮点型：float \ double

字符型：char

布尔型：boolean

引用数据类型：

类（class）

接口（interface）

数组（array）

变量在类中声明的位置：

成员变量

局部变量

整形数据

byte：1byte（字节）=8bit（位）

表述范围：-128~127

1bit存0或者1有两种可能，1byte有8bit，因此1byte可以有2^8种的种组合方式

short：1short = 2byte

表述范围：-2^{15}~2^{15}-1

2^{16}种排列方式

int（4字节）

表述范围：-2^{31}~2^{31}-1（约21亿）

2^{32}种排列方式

long（8字节）

表述范围：-2^{63}~2^{63}-1

2^{64}种排列方式

整型数据注意点

byte的表示范围-128~127，超过范围会编译错误
声明long型数据，结尾要以“l”或者“L”结尾

浮点型数据

float（4字节）小数可以精确到七位有效数字，

定义float类型变量，必须以“f”或“F”结尾

double（8字节）精度是float两倍

科学计数法

public class 浮点数 {
    public static void main(String[] args) {
        float f1=1.36E+5F;//科学计数法
        System.out.println(f1);
    }
}

double类型科学计数法

public class 浮点数 {
    public static void main(String[] args) {
        double d1=1.36E+5D;//科学计数法
        System.out.println(d1);
    }
}

十六进制double类型

public class 浮点数 {
    public static void main(String[] args) {
        double six = 0x12.2P2;//十六进制12.2×2²（P表示2的次方）
        System.out.println(six);

    }
}

字符类型

1、1字符 = 2字节

2、定义char通常使用‘ ’，智能存一个字符，两个报错

public class 字符类型 {
    public static void main(String[] args) {
        char c1 = 'C';
        System.out.println(c1);
    }
}
//输出C

用途：1、声明一个字符

2、转义字符

3、直接使用Unicode值表示字符型常量

public class 字符类型 {
    public static void main(String[] args) {
        char c1 = 'C';
        char cc = '\u0043';
        System.out.println(c1);
        System.out.println(cc);
    }
}
//输出：
C
C

布尔类型

布尔型：boolean

只有false（0）和true（非0）两个值

常用来条件判断、循环结构中使用

字符串类型String

字符串类型不是基本数据类型，是引用数据类型，但使用方式与基本数据类型一致

可以串接另一个字符串，也可以串接其他类型数据

public class string变量 {
    public static void main(String[] args) {
        String s1 = "Hello World";
        System.out.println(s1);
    }
}

声明String类型变量，必须使用一对" "

可以声明空串，但是不能声明空字符变量

数字和字符串拼接

public class string变量 {
    public static void main(String[] args) {
        String s1 = "Hello World";
        int number = 110;
        boolean what = true;
        String a = "电话号：";
        System.out.println(a + number + what );// + 是连接符号
    }
}
//电话号：110true

字符串练习1：

public class 字符串练习 {
        public static void main(String[] args) {
            char c = 'a';//ASCII码97
            int num = 10;
            String str = "hello";
            //第一个+表示运算，字符变量和整数运算，结果是整型，再和str拼接
            System.out.println(c + num + str);//输出107hello
            System.out.println(c + str + num);//输出ahello10
            System.out.println(c + (num + str));//输出a10hello
            System.out.println((c + num) + str);//输出107hello
            System.out.println(str + num + c );//输出hello10a
        }
}

字符串练习2：

public class 字符串练习 {
        public static void main(String[] args) {            
            System.out.println("*   *");//成功输出范例
            // 这里的加号是运算，因为都是字符类型
            System.out.println('*' + '\t' + '*');//不能输出
            // 第一个+表示拼接，合成字符串，再和字符变量拼接
            System.out.println('*' + "\t" + '*');//成功输出
            System.out.println('*' + '\t' + "*");//不能输出
            System.out.println('*' + ('\t' + "*"));//成功输出
            
        }
}

变量类型的转换

隐式转换

自动类型提升：

容量小的数据类型的变量与容量大的数据类型的变量做运算，会自动提升为容量大的数据类型（byte、char、short-->int-->long-->float-->double）
byte、char、short做运算，结果为int类型

public class 类型转换 {
    public static void main(String[] args) {
        char cc = 'a';
        int i1 = 12;
        int sum = cc + i1;
//        System.out.println(sum);
        //输出109
        //————————————————————————————
        short s = 10;
        char sum = s + cc;
        short qq = s + cc;
        //编译错误，两者运算既不是char也不是short
        byte q = 12;
        char qw = cc + q;
        byte qe = cc + q;
        //编译错误，两者运算既不是char也不是byte
    }
}

强制类型转换

需要使用强制符（）
强制类型转换，可能导致精度损失

public class 强制类型转换 {
    public static void main(String[] args) {
        double d1 = 12.3;
        int i1 = (int)d1;//截断操作，损失精度
        // ————————————————————————————————————————
        long l1 = 123;
        short s2 =  (short)l1;//没有精度损失
        // ————————————————————————————————————————
        int i2 = 128;
        byte b = (byte)i2;//输出-128，精度损失
        System.out.println(b);
    }
}

如果原始数据的值，超出目标表示范围，数据的结果是原始数据的值，取余目标所能表示数字个数

public class 强制类型转换 {
    public static void main(String[] args) {
        int i =128;
        byte b = (byte)i;
        System.out.println(b);//-128
        //如果原始数据的值，超出目标表示范围，数据的结果是原始数据的值，取余目标所能表示数字个数
        System.out.println(b % 256);//-128
    }
}

类型转换需要注意的地方

1、long和float类型的声明

public class 类型转换注意点 {
    public static void main(String[] args) {
        long l = 123213;//数字不大，末尾没加'l'或者'L',z自动变为整型
        System.out.println(l);
//        long l1 = 99999999999999999;//编译失败：整数太大，用四个字节存不下
        //以下编译通过，用八个字节存
        long l1 = 99999999999999999L;
        long l2 = 99999999999999999l;
        //————————————————————————————————————————————————————
        //编译错误
        //float f = 12.3
        float f = 12.3f //通过

    }
}

2、默认类型

整型常量：默认类型为int型

浮点型常量：默认类型为double型

public class 类型转换注意点 {
    public static void main(String[] args) {
        byte b = 12;
        //byte b1 = b+1 编译不通过，越界
        float f1 = b + 12.3;//从double到float可能会有精度损失
    }

3、字符串类型不能转换为整型

public class 字符串练习 {
        public static void main(String[] args) {
            String s2 = 123 + "";
            System.out.println(s2);
//            int numb = s2;//字符串类型不能转换整型
//            int numb = (int)s2;//强制类型转换也不行
//              但可以使用包装类
              int numb = Integer.parseInt(s2);
              System.out.println(numb);
        }
}

常量优化机制

package 第一章基础;

public class 常量优化机制 {
    public static void main(String[] args) {
        byte res = 3 + 4;
        System.out.println(res);
    }
}

在上面的案例中，虽然运算结果是int类型，赋值给byte类型，但Java中存在着常量优化机制

当运算结果在byte范围内时，会正常编译，否则报错

ASCII是什么

刚开始提到1byte=8bit时，每1bit可能存0或1，那么1byte的8个进制位，有256种状态，一种状态就是一种字符，也就是256种字符，从00000000到11111111

缺点：不能表示所有字符

相同的编码表示的字符不一样（主要是语言差异造成的）

UTF-8是什么

是互联网使用最广的Unicode实现方法

UTF-8是一种边长的编码方式，可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度

变量练习题

判断是否能通过编译：

1）short s = 5 //不通过

s = s - 2 //2是整型，s是short类型，int-->short有精度损失，除非强制抓换

2）byte b = 3

b = b + 4 //不通过，原因与上题同理

b = (byte)(b+4) //通过，强制类型转换

3）char c = 'a'

int i = 5

float d = .314F

double result = c + i + d //通过

4）byte b = 5

short s = 3

short t = s + b //当char、byte、short运算时，结果为int类型

键盘输入

Scanner

输入整形数据

import java.util.Scanner;//导包
public class 键盘输入 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);//实例化，创建Scanner类的scan对象
        int num=scan.nextInt();
        System.out.println(num);
    }
}

输入其他类型的数据

import java.util.Scanner;//导包
public class Scannertest {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);//实例化，创建Scanner类的scan对象
        System.out.print("请输入你的姓名：");
        String name = scan.next();
        System .out.print("请输入年龄");
        int age=scan.nextInt();
        double weight = scan.nextDouble();//必须输入对应类型的值，不然会异常
        System.out.print("请输入性别（男/女）");
        String gender = scan.next();
        System.out.print("你的性别是" + gender.charAt(0));
        System.out.print("是否学生？（true/false");
        boolean isstu = scan.nextBoolean();
    }
}

练习

从键盘输入三个数，进行排序

import java.util.Scanner;
public class 三个数字排序 {
    public static void main(String[] args) {
        int a, b, c,temp;
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入第一个数字：");
        a = scan.nextInt();
        System.out.print("请输入第二个数字：");
        b = scan.nextInt();
        System.out.print("请输入第三个数字：");
        c = scan.nextInt();
        //嵌套结构
        if (a>b){
            temp = b;
            b = a;
            a = temp;
            if (b>c){
                temp = c;
                c = b;
                b = temp;
            }
        } else{
            if (b > c) {
                temp = c;
                c = b;
                b = temp;
            }
        }
        System.out.println("三个数从小到大为：" + " " + a +" " +  b +" " +c);
    }
}

猜数字小程序

import java.util.Scanner;
public class 猜数小程序 {
    public static void main(String[] agrs) {
        int number = (int)(Math.random()*100);
        //Math.random()默认生成double类型的0.0-1.0，所以*100就是0.0-100.0
        //公式[a,b] == Math.random()*((b-a)+a)
        Scanner scan = new Scanner(System.in);
        System.out.println("已经成功生成一个随机数，请开始你的表演");
        while (true) {
            System.out.print("请输入一个整数：");
            int newnum = scan.nextInt();
            if (newnum > number) {
                System.out.println("大了，猜小点！");
            } else if (newnum < number) {
                System.out.println("小了，猜大点！");
            } else if (newnum == number) {
                System.out.println("恭喜你！猜对了！");
                System.out.println("正确答案为：" + number);
                break;
            }
        }
    }
}

Java语法基础 - 变量