Java基础知识_age、day-3、3name、#abc中哪个有效标识符

Java基础知识

1.注释

//  单行注释

/* 
 姓名    多行注释
 年龄
*/ 
    
/** 
@name 李佩蓉
@age 18     文本注释
*/ 
1
2
3
4
5
6
7
8
9
10
11

注释不会被运行，养成良好的代码习惯

2.标识符

类名、变量名、方法名都统称为标识符

标识符的规则

• 不能是关键字(下图都是关键字)
  

• 所有标识符以字母(A-Z,a-z)、美元符($)、下划线(_)开始，不能以数字开头

  合法的标识符：age、 Age、 $m1、_01

  不合法的标识符: 1age、-lili、#abc、*aa

3.数据类型(八大数据类型)

• 布尔型：判断是否
• 整形：整数
• 浮点型：小数
• 字符型：文字
  

基本数据类型举例

/*
        * 基本数据类型
        * */

        //整数
        int A = 10;
        long B = 20L; //后面加上L
        short C = 30;
        byte D =40;

        //小数：浮点型
        float E =3.12F; //后面加上F
        double F =3.14159265898;

        //字符
        char name = '李';
        //String不是关键字，是类
        //String name1 = "李佩蓉";

        //布尔：是非
        boolean flag =true;
        boolean flag1 = false;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

扩展

1. 整型扩展

 int i = 10;
        int i1 = 010; //八进制0
        int i2 = 0x10;//十六进制0x 0~9 A~F

        System.out.println(i); //10
        System.out.println(i1); //8
        System.out.println(i2); //16
1
2
3
4
5
6
7

2.浮点数扩展

float：有限、离散、舍入误差、大约、接近但不等于

最好完全避免使用浮点数进行比较

最好完全避免使用浮点数进行比较

最好完全避免使用浮点数进行比较

        float f = 0.1f;
        double d = 0.1;
        System.out.println(f == d); //false

        float f1 = 3.551663484615f;
        float f2 = f1 + 1;
        System.out.println(f1 == f2); //false

        float f3 = 551663484615f;
        float f4 = f3 + 1;
        System.out.println(f3 == f4); //ture
1
2
3
4
5
6
7
8
9
10
11

3.字符扩展

所有字符本质上还是数字

        char a = 'a';
        char a2 = '李';

        System.out.println(a); //a
        System.out.println((int)a); //  97  强制转换
        System.out.println(a2);//李
        System.out.println((int)a2); //26446    强制转换

        //所有字符本质上都是数字
        //编码 Unicode 0-65536（2的16次方）
        //97=a 65=A
        //U0000 UFFFF 正常Unicode编码转义方式
        char a3 = '\u0061';
        System.out.println(a3); //a

        //转义字符
        // \t 制表符
        // \n 换行
        System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.布尔扩展

       boolean flag = true;
        if (flag==true){}; //新手
        if(flag){}  //老手
1
2
3

4.类型转换

类型转换分为强制类型转换和自动类型转换

强制类型转换：高转低

强制转换格式 (数据类型)变量

自动类型转换：低转高

数据类型排序

//强制类型转换发生溢出问题     
       int i = 128;
        byte b = (byte)i; //强制类型转换 int(高)-->byte(低)
        System.out.println(i); //128
        System.out.println(b); //-128 内存溢出(byte最大127)
        //强制转换格式 (数据类型)变量

//自动转换类型
        int i1 = 128;
        double b1 = i1; //自动类型转换 int(低)-->double(高)
        System.out.println(i1); //128
        System.out.println(b1); //128.0 double类型

//转换出现精度问题
        System.out.println((int)29.3); //29
        System.out.println((int)-56.2f); //-56   精度问题

//数字与字母之间的转换
        char c ='a';
        int d =c+1;
        System.out.println(c); //a
        System.out.println(d); //98 转换为int类型a=97 d=97+1
        System.out.println((char)d); //b 转换为char类型 a下一位

//操作数大的时候注意溢出
        int money = 1000000000;
        int years = 20;
        int total= money*years;
        long total2 =money*years;
        System.out.println(total); //-1474836480 计算的时候产生溢出
        System.out.println(total2); //-1474836480 依然溢出 默认是int，转换之前就出现问题了

        //解决办法 先把一个数转换为long类型
        long total3 =money*(long)years;
        System.out.println(total3); //200000000
        
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

总结

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

5.变量、常量、作用域

Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型、作用域

1.变量

变量就是可变化的量，每个变量都必须声明其类型

变量注意：

1. 每个变量都有类型，类型可以是基本类型也可以是引用类型
2. 变量名必须是合法的标识符

 public static void main(String[] args) {
        int a = 1;
        String name = "lipeirong";
        char x = 'X';
        double pi = 3.14;
    }
1
2
3
4
5
6

2.常量

final 常量名=值;

常量名一般用大写字符

public class Demo7 {
    //修饰符 不存在先后顺序
    static final double PI = 3.14; //常量
    public static void main(String[] args) {
        System.out.println(PI);

    }
}
1
2
3
4
5
6
7
8

3.作用域

public class Demo6 {

    //类变量 static
    static double salary = 3000;

    //属性：变量
    //实例变量 从属于对象 如果不进行初始化 默认这个类型的默认值
    //布尔值默认false
    //除了基本类型，其余默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {

       //局部变量 必须声明和初始化值 开始
        int i =10;
        System.out.println(i); //10 结束

       //变量类型 变量名字=new Demo6();
        Demo6 demo6 = new Demo6();
        System.out.println(demo6.age); //0
        System.out.println(demo6.name); //null

        //类变量 static
        System.out.println(salary); //3000.0

    }


    //其他方法
    public void add(){

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

6.基本运算符

• 算数运算符：+、-、*、/、%(取余)、++、–
• 赋值运算符：=
• 关系运算符：>、<、>=、<=、==(等于)、!=(不等于)、instanceof
• 逻辑运算符：&&(与)、||(或)、！(非)
• 位运算符：&、|、^、~、>>、<<、>>>(了解)
• 条件运算符：? 、：
• 扩展赋值运算符：+=、-=、*=、/=

//二元运算符 
public static void main(String[] args) 
        //Ctrl+D :复制等前行到下一行
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;
        System.out.println(a+b);//30
        System.out.println(a-b);//-10
        System.out.println(a*b);//200
        System.out.println(a/b);//0  int类型
        System.out.println(a/(double)b);//0.5
    }
        
public static void main(String[] args) {
        long a = 12312322L;
        int b = 123;
        short c =10;
        byte d =8;

        System.out.println(a+b+c+d); //12312463 long类型
        System.out.println(b+c+d); //141 int类型
        System.out.println(c+d); //18 int类型

        //多个参数中有long类型 结果就为long类型
        //多个参数中，如果没有long类型 结果就为int类型
        //同理 如果有个数是double 结果就为double类型
    }
 
  public static void main(String[] args) {
        //关系运算符返回的结果： 正确 错误 布尔值

        int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(a>b);//false
        System.out.println(a<b);//ture
        System.out.println(a==b);//false
        System.out.println(a!=b);//true
        //取余：模运算
        System.out.println(c%a);//1   21/10=2......1
    } 
//一元运算符 
public static void main(String[] args) {
        //一元运算 ++自增 --自减
        int a = 5;
        int b= a++; //执行完这行代码后，先给b赋值，再自增
        System.out.println(b); //5  赋值
        System.out.println(a); //6  自增

        int d = 3;
        int c=++d;  //执行这行代码前，先给d自增，再给c赋值
        System.out.println(c);//4 自增
        System.out.println(d);//4 赋值

        //幂运算2^3 2*2*2 使用工具类来操作
       double pow = Math.pow(2,3);
        System.out.println(pow); //8.0
    }
 //逻辑运算
 public static void main(String[] args) {
        // 与&& and    或|| or      非! 取反

        boolean a = true;
        boolean b= false;

        System.out.println("a && b:"+(a&&b)); //一个假的就为假  a && b:false
        System.out.println("a || b:"+(a||b)); //一个真的就为真  a || b:true
        System.out.println("!（a&&b）:"+!(a&&b));//真的变成假的 假的变为真的  !（a&&b）:true

        //短路运算
        int c = 5;
        boolean d=(c<4)&&(c++<4);
        System.out.println(d); //false
        System.out.println(c); //5  只运行了c<4为假之后发生的短路
    }
  //位运算
  public static void main(String[] args) {
        /*
        *  A = 0011 1100
        *  B = 0000 1101
        *
        *  A&B = 0000 1100 两个为1才为1
        *  A|B = 0011 1101 一个为1就为1
        *  A^B = 0011 0001 两个相同就为0
        *  ~B  = 1111 0010 取反
        *
        *  2*8怎么运算最快？ 2*2*2*2
        *  << 左移 *2
        *  >> 右移 /2
        * 效率高
        *  0000 0000  0
        *  0000 0001  1
        *  0000 0010  2
        *  0000 0011  3
        *  0000 0100  4
        *  0000 1000  8
        *  0001 0000  16
        * */
        System.out.println(2<<3); //16
    }
//三元运算符
public class Demo8 {
    public static void main(String[] args) {
        //x?y:z
        //如果x==true,则结果为y,否则结果为z
        int score = 80;
        String type = score<60?"不及格":"及格"; //必须掌握
        //if
        System.out.println(type); //及格
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

优先级

7.包机制

包的本质就是文件夹

一般利用公司域名倒置作为包名 com.li.xxx

创建包 package 导包import

com.li.xxx.* 导入xxx所有的包

8.JavaDoc生成文档

javadoc命令是用来生成自己的API文档

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的jdk版本
• @param 参数名
• @return 返回值情况
• @throws 异常抛出情况

package com.lpr.base;

/**
 * @author lipeirong
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;

    /**
     * @author lipeirong
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
        //通过命令行 javadoc 参数 java文件
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

用命令行生成文档

打开文件所在地

在当前文件夹中打开doc命
输入指令

回到文件地址 打开index.html，生成成功

用idea生成文档

1. Tools—>Generate JavaDoc
   
2. 修改

   • 选择是整个项目还是模块还是单个文件

   • 文档输出路径

   • Locale 选择地区，这个决定了文档的语言，中文就是zh_CN

   • 传入JavaDoc的参数，一般这样写 -encoding UTF-8 -charset UTF-8 Doc.java
     

3. 运行中
   
4. 运行成功