【狂神说Java】2021-03-02学习笔记：java基础

语法

注释、标识符、关键字

数据类型

类型转换

变量常量

运算符

包机制、JavaDoc

注释

书写注释是一个好习惯。

//单行注释

/* 多行注释 */

/**
文档注释：
*/

拓展：有趣的代码注释

标识符

类名、变量名以及方法名都被称为标识符

public class Hello {     //Hello就是类名
    public static void main(String[] args) {    //main就是方法名
        String teacher = "大爷"；    //teacher就是变量名
        System.out.println("hello,daye!");
    }
}

所有标识符都是以字母、美元符（$）、下划线开始

首字母之后字母、美元符、下划线、数字任意组合

你能用关键字作为变量名或方法名

标识符是大小写敏感的

不建议用中文命名，不建议用拼音命名（很low）

数据类型

强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

弱类型语言

Java的数据类型分为两大类：基本类型（数值类型、boolean类型）、引用类型（类、接口、数组）

    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        int num1 = 1000;   //最常用
        byte num2 = 20;   //num=200就报错了
        short num3 = 30;
        long num4 = 30L;   //Long类型要在数字后面加个L

        //浮点数（小数）
        float num5 = 50.1F;
        double num6 = 3.14159261651651;

        //字符
        char name='A';
        String namea = "大爷";   //String不是关键字，是一个类


        //布尔值
        boolean flag = true;
        boolean flagb = false;

    }

位（bit）是计算机内部数据存储的最小单位

字节（byte）是计算机中数据处理的基本单位，B，1B=8bit

字符：是指计算机中使用的字母、数字、字和符号

1024B=1KB 1024KB=1M 1024M=1G

 public static void main(String[] args) {
     //整数拓展：二进制0b   十进制   八进制0   十六进制0x   
     int i = 10;    //十进制
     int i2 = 010;   //八进制0
     int i3 = 0x10;   //十六进制0x

     System.out.println(i);
     System.out.println(i2);
     System.out.println(i3);
/*运行结果：
10
8
16

Process finished with exit code 0
*/
     

     
     
     
     //------------------------------------------------
     //浮点数拓展：浮点数位数有限，最好别使用浮点数进行比较  
     float f = 0.1f;
     double d = 1.0/10;
     System.out.println(f==d);   //false
     System.out.println(f);
     System.out.println(d);
     /*运行结果：
false
0.1
0.1

Process finished with exit code 0
     */
        float d1 = 23131312312312313f;
        float d2 = d1+1;
        System.out.println(d1=d2);  //true
/*运行结果：
true

Process finished with exit code 0
     */
   
     
     
     
     
     //------------------------------------------------
     //字符拓展:所有的字符本质还是数字  编码  Unicode 2字节  65536（216）
     char c1 = 'a';
     char c2 = '中';
     System.out.println(c1);
     System.out.println((int)c1);    //强制换行
     System.out.println(c2);
     System.out.println((int)c2);   //强制换行
/*运行结果：
a
97
中
20013

Process finished with exit code 0
     */
     
     
     
      char c3 = '\u0061';
     System.out.println(c3);    //编码
/*运行结果：
a

Process finished with exit code 0
     */
     
      //转义字符:\t 制表符    \n 换行  ……
     
     
      //------------------------------------------------
      //布尔值拓展
        boolean flag = true;
        if (flag==true){}   //新手
        if (flag){}    //老手 less is more!代码要精简易读
     
     
    }

类型转换

java是强类型语言，所以进行有些运算时，需要用到类型转换。

低------------------------------------------------------->高

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

运算时，不同类型的数据先转化为同一类型，然后进行运算

    public static void main(String[] args) {
        //内存溢出
        //强制转换 高->低 （类型）变量名
        //自动转换 低->高
        int i=128;
        byte b = i;  //报错，因为int优先级高于byte，应更改为byte b = (byte)i;

        System.out.println(i);
        System.out.println(b);
/*运行结果：
128
-128
Process finished with exit code 0
*/
/*
注意点：
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候，强制转换
4.转换的时候可能存在内存溢出，或者精度问题！
*/
        char c = 'a';
        int d = c+1;
        System.out.println(d);
        System.out.println((char) d);
/*运行结果：
98
b
Process finished with exit code 0
*/

        
        //操作比较大的数的时候，注意溢出新问题
        //JDK新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        System.out.println(money);
/*运行结果：
1000000000
Process finished with exit code 0
*/
        
        
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;   //计算的时候溢出了
        long total2 = money*years;   //计算的时候溢出了
        System.out.println(total); 
        System.out.println(total2);   //默认是int，转换之前已经存在问题了
        long total3 = money*((long)years);
        System.out.println(total3);   //输出结果正常
/*运行结果：
-1474836480
-1474836480
20000000000
Process finished with exit code 0
*/
        //long类型的变量数值最后的L最好用大写！
    }

变量常量

java是强类型语言，每个变量都必须声明其类型

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

注意事项：

1.每个变量都有类型，类型可以是基本类型，也可以是引用类型

2.变量名必须是合法的标识符

3.变量声明是一条完整的语句，因此每个声明都必须以分号结束

变量的作用域分为三种：

类变量，实例变量，局部变量

type varName [=value][{,varName[=value]}]
    //数据类型 变量名=值；可以使用逗号隔开来声明多个同类型变量
public static void main(String[] args) {
    //变量的声明    
    	int j,k,l;   //不建议这样写
        int q=1,w=2,r=3;   //不建议这样写
        int a=1;      //建议这样写,程序可读性强
        int b=2;
        int c=3;
        String name = "zhaodaye";  //引用类型
        char x = 'X';
        double pi = 3.14;
}
   
======================================================== 
    //变量的作用域
    static int allClicks=0;  //类变量，有static（静态的）
    String str="hello,world!";  //实例变量
    public void method(){
        int i=0;      //局部变量
    }
--------------------------------------------------------
     //例：
public class Demo106 {
    //类变量 static
    static double salary = 2500;
    //属性：目前可以理解为变量
    
    //实例变量（位于方法外，类内）：从属于对象；如果不自行初始化，这个类型的默认值就是0或者0.0或者false（布尔值默认），除了基本类型，其余的默认值都是null；
    String name;
    int age;
    
    //main方法
    public static void main(String[] args) {
        //局部变量；使用之前必须声明和初始化值
        int i;
        System.out.println(i);  //报错：Variable 'i' might not have been initialize（必须赋予变量初始值）
    
        //实例变量的使用：变量类型 变量名字 = new Demo08()
        Demo106 demo106 = new Demo106();
        System.out.println(demo106.age);
        System.out.println(demo106.name);
        
         //类变量  static
        System.out.println(salary);  //如果没有static会报错
    }
    
    //其他方法
    public void add(){
        System.out.println(i);// 报错：Cannot resolve symbol 'i'（因为i是局部变量，方法外不能使用）
    }
}
/*运行结果：
10
0
null
2500.0
Process finished with exit code 0
*/

常量名一般使用大写字符

public class Demo106{
    //修饰符(此处表示static与final)，不存在先后顺序
    static final double PI = 3.14;
    public static void main(String[] args){
        System.out.println(PI);
    }
}
/*运行结果：
3.14
Process finished with exit code 0
*/

变量的命名规范：

1.所有变量、方法、类名：见名知意

2.类成员变量：首字母小写和驼峰原则：monthSalary（除了第一个单词以外，后面的单词首字母大写）

3.局部变量：首字母小写和驼峰原则

4.常量：大写字母和下划线：MAX_VALUE

5.类名：首字母大写和驼峰原则：Man,GoodMan

6.方法名：首字母小写和驼峰原则：run(),runRun()

运算符

操作数中有一个是Long，整体就是Long

关系运算符返回的结果是布尔值，对或者错

取余就是模运算

一元运算符：++ –

public static void main(String[] args) {
        int a = 3;
        int b = a++;    //执行完这行代码后，先给b赋值，再自增
        System.out.println(a);
        int c = ++a;   //执行完这行代码前，先自增，再给c赋值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    
        //幂运算
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    
}
/*运行结果：
4
5
3
5
8.0
Process finished with exit code 0
*/


 public static void main(String[] args) {
        //与（and）   或（||）  非（!）
        boolean a = true;
        boolean b = false;

        System.out.println("a&&b:"+(a&&b));
     //逻辑与运算：两个变量都为真，结果才为真
        System.out.println("a||b:"+(a||b));
     //逻辑或运算：两个变量有一个为真，结果就为真
        System.out.println("!(a&&b):"+(!(a&&b)));
     //逻辑非运算：如果是真则为假，如果是为假则为真

        //短路运算：绝绝绝！！！
        int c = 5;
        boolean d = (c<4)&&(c++<4);
     //因为c<4已经是false了，所以后面的就不执行了，所以结果c还为5
        System.out.println(d);
        System.out.println(c);
/*运行结果：
a&&b:false
a||b:true
!(a&&b):true
false
5
Process finished with exit code 0
*/
    }

位运算符：&, |, ^, ~, >>, <<, >>>

public class Demo109 {
    public static void main(String[] args) {
        /*
        位运算
        A = 0011 1100
        B = 0000 1101
--------------------------------------------
	A&B = 0000 1100  AB的对应位置，两个都是1，才是1
        A|B = 0011 1101  AB的对应位置，有1就是1
        A^B = 0011 0001  AB的对应位置，数字相同则为0，不同则为1
        ~B = 1111 0010

        2*8 = 16  2*2*2*2
        <<  左移  相当于给数字*2
        >>  右移  相当于给数字/2
        * */
        System.out.println(2<<3);
/*运行结果：
16
Process finished with exit code 0
*/
    }

扩展赋值运算符：+=， -=， *=， /=

public class Demo110 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a+=b;  //a=a+b
        System.out.println(a);
        a-=b;  //a=a-b
        System.out.println(a);

        //字符串连接符 +
        System.out.println(a+b);
        System.out.println(""+a+b);//1020
        System.out.println(a+b+"");//30
/*运行结果：
30
10
30
1020
30
Process finished with exit code 0
*/
    }

条件运算符： ？：

public static void main(String[] args) {
        //三元运算符
        //x?y:z
        //如果x==true，则结果为y，否则结果为z
        int score = 80;
        String type  = score<60 ? "不及格" : "及格";
        System.out.println(type);
/*运行结果：
及格
Process finished with exit code 0
*/
    }

优先级()，建议用！清楚明白！

不确定的tip：设置-编辑器-常规-鼠标里第二选项 打勾勾 保证不管中英文输入，都是英文标点

包机制、JavaDoc

包机制：为了更好地组织类，用于区别类名的命名空间（相当于文！件！夹！） package pkg1[.pkg2[.pkg3……]]

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

例如：www.baidu.com 包名为：com.baidu.www

为了能够使用某一包的成员，我们需要在java程序中明确导入该包。使用“import”语句可完成此功能

import package[.package2……].(classname|*);

不能包中包问题解决：project旁边小齿轮->设置图标里面Compact Middle Packages勾去掉

---

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

参数信息：

@author 作者名

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况

package com.daye.base;

/**
 * @author zhaodaye
 * @version 1.0
 * @since 1.8
 */

public class Doc {
    String name;
    /**
     * @author zhaodaye
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

javadoc Doc.java 通过命令行生成文档

javadoc -encoding UTF-8 -charset UTF-8 Doc.java 使文档中的中文可以正常显示

---

参考视频：狂神java视频之变量https://www.bilibili.com/video/BV12J41137hu?p=26