java基础语法

1.注释、标识符、关键字
2.数据类型
3.类型转换
4.变量、常量

1、注释：

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
注释并不会被执行，是给我们写代码的人看的
书写注释是一个非常好的习惯
平时写代码一定要注意规范。

单行注释 //
多行注释 /* */
文档注释 /** * */

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

        /*多行注释*/
        /*
        我是多行注释
        我是多行注释
        我是多行注释(Ctrl+D是复制上一行)
        */

        //JavaDoc:文档注释   /**  */
        /**
         * @Description Hello World
         * @Author 狂神说Java_刘婷
         **/
    }
}

2、标识符：

Java 所有的组成部分都需要名字。类名、变量名、方法名都被称为标识符

标识符注意点

所有标识符都应该以 字母、$(美元符)、_(下划线) 开头
首字母之后可以是 字母、$、_ 或数字任何字符组合
关键字不能作为变量名或方法名
标识符大小写敏感
可以用中文命名，但不建议使用，即使用拼音命名也Low

合法标识符：字母、美元符$、下划线_

public class Demo01 {
    public static void main(String[] args) {
        // 大小写敏感
        String hello = "fs";
        String Hello = "fs";

        //合法
        String Ahello = "fs";
        String hhello = "fs";
        String $hello = "fs";
        String _hello = "fs";

        //不合法
//        String 1hello = "fs";
//        String #hello = "fs";
//        String *hello = "fs";
    }
}

3、关键字：

4、数据类型：

强类型语言

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

弱类型语言

JavaScript，Python...

Java的数据类型分为两大类

基本类型（primitive type），有8大基本类型，此外都是引用类型
引用类型（reference type）

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

        //整数
        int num1 = 10000000;    //不能超过21亿、最常用
        byte num2 = 20;   //不能超过127
        short num3 = 30;   //30亿
        long num4 = 30L;    //加L


        //小数
        float num5 = 50.1F;
        double num6 = 3.1216864565757;


        //字符
        char name = '国';
        String namea = "锋声";    //String不是一个关键字。是一个类

        //布尔
        boolean flag1 = true;
        boolean flag2 = false;

    }
}

扩展

//整数拓展
// 进制 二进制 0b 十进制  八进制 0  十六进制 0x
int i1 = 10;
int i2 = 010; //八进制 0 0~7(0-7)  010(8)
int i3 = 0x10; //十六进制 0x  0~9(0-9)  A~F(10-15)  0x10(16)

//浮点数扩展：
//面试题：银行业务字母怎么表示钱? BigDecimal(数学工具类)
//float double是有问题的，最好避免使用浮点数进行比较
float f = 0.1f; 	//0.1
double d = 1.0/10;  //0.1
System.out.println(f==d); //false
//浮点数 位有限，舍入误差，大约
//最好避免使用浮点数进行比较
float f1 = 23131313131f;
float f2 = f1+1;
System.out.println(f1==f2); //true

//字符扩展：所有字符本质还是数字
char c1 = 'a';
char c2 = '中';

System.out.println(c1);		//a
System.out.println((int)c1);//强制类型转换,97
System.out.println(c2);		//中
System.out.println((int)c2);//强制类型转换,20013

//编码 Unicode表（97=a,65=A）2字节 0-65536
//U000~UFFFF 十六进制（u0061=a,相当于十进制的97）
System.out.println('\u0061');  //a '\'是转义字符

//转义字符
// \t制表符
// \n换行
// 。。。
System.out.println("Hello\tWorld");

//对象 从内存分析
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){}	//老手这样写 Less is More(代码要精简易读)

5、字节：

位(bit)：是计算机内部数据存储的最小单位，11001100是一个八位二进制数
字节(byte, B)：是计算机中 数据处理 的基本单位，习惯上用大写B表示
1B(byte) = 8bit，1字节等于8位
字符：指计算机中使用的字母，数字，字和符号

1bit表示1位
1Byte表示一个字节 1B=8b
1024B = 1KB, 1024KB = 1M, 1024M = 1G

6、类型转换：

由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

容量高–>低：

运算中，不同类型的数据先转化位同一类型，再进行运算。

• 强制转换，（类型）变量名，容量由高到低
• 自动转换，容量由低到高

//强制转换 （类型）变量名 高--低
//自动转换 低--高
int i = 128;
byte b = (byte)i; //强制转换 内存溢出 -128~127
double d =i; //自动转换

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

//当操作数比较大时，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000; //10亿，下划线不会被打印出来
System.out.println(money); //1000000000
int years = 20;

int total = money*years;  //数据大，溢出
System.out.println(total); //-1474836480

long total2 = money*years; //默认是int，转换前就有溢出问题
System.out.println(total2); //-1474836480

long total3 = money*(long)years; //先把一个数转Long
System.out.println(total3); //20000000000

7、变量：

变量是什么：就是可以变化的量！
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基层的存储单元，其要素包括变量名，变量类型和作用域。

注意事项：
每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

变量作用域

• 类变量

   在类里，整个类里可以使用，前面必须加static；“static int a = 666;”
  

• 实例变量

   在类里，从属于对象；“int age;//0”
   如果不自行初始化，这个类型的默认值 0,0.0
   布尔值：默认是false；除了基本类型，其他的默认值都是null；
  

• 局部变量

   在方法中，使用时必须声明和初始化值；“int cba = 666;"
  

变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写+驼峰原则：lastName
局部变量：首字母小写+驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写+驼峰原则：Man，GoodMan
方法名：首字母小写+驼峰原则：run()，fastRun()

7、常量：

• 常量（Constant)：初始化（initialize）后不能再改变值！不会变动的值。

• 所谓常量可以理解成一种特殊的变量，他的值被设定后，在程序运行过程中不允许被改变。

  final 常量名 = 值；
  final double PI = 3.14;
  

• 常量名一般使用大写字符。

8、运算符：

算术运算符:+, -, *, /, %, ++, -
赋值运算符=
关系运算符:>，<, >=, <=, ==, != instanceof
逻辑运算符:&&, |，!
位运算符:&，|, ^, ~,》, <<, >>>了解! ! ! )
条件运算符? :
扩展赋值运算符:+=, -=, *-=,/log.cn.onllowv. _wind

算术运算符

int a=10;
int b=20;
System.out.println(a/b); //0
System.out.println((double)a/b); //0.5

long c=12300000000;
System.out.println(a+b); //int
System.out.println(a+c); //long 自动转换式子中容量大的数据类型

自增自减运算符

// ++自增 --自减 单目运算符
int a = 3;
int b = a++; //b=a,a=a+1 先赋值 即b=3 a=4
int c = ++a; //a=a+1,c=a 先自增 即a=5 c=5

System.out.println(a); //5
System.out.println(b); //3
System.out.println(c); //5

//幂运算 2^3 2*2*2=8
double pow = Math.pow(2,3); // (底数，指数)double型
System.out.println(pow); //8.0

//扩展：笔试题 i=5 s=(i++)+(++i)+(i--)+(--i) s=?
int i=5;
int s=(i++)+(++i)+(i--)+(--i);
System.out.println(s); //24

逻辑运算符

&& 逻辑与运算：两个变量都为真，结果为true
|| 逻辑与运算：两个变量有一个为真，结果为true
! 取反，真变为假，假变为真

// 与(snd) 或(or) 非(取反)
boolean a = true;
boolean b = false;

System.out.println(a&&b); // false
System.out.println(a||b); // true
System.out.println(!(a&&b)); // true

int c=5;
boolean d = (c<5)&&(c++<5); //第一个值为false，后面就不进行判定了
System.out.println(d); //false
System.out.println(c); //5 c++未执行

位运算

/*
    A = 0011 1100
    B = 0000 1101

    A&B 0000 1101 按位与
    A|B 0011 1101 按位或
    A^B 0011 0001 异或
    ~B  1111 0010 非

    面试题：2*8 怎么算最快？ 2<<3
    <<左移  *2 效率极高！！
    >>右移  /2
   */
System.out.println(2<<3); // 16

赋值运算符

int a = 10;
int b = 20;

a+=b; // a = a+b
a-=b; // a = a-b

System.out.println(a); //10
//字符串连接符 + ，转化为String类型,然后拼接    注意！！
System.out.println(""+a+b); //1020
System.out.println(a+b+""); //30 先进行运算，再转为String拼接
System.out.println(a+b+"str"); //30str

三元运算符

// x ? y : z
//如果x为真，则结果为y,否则为z
//if(x) y; else z;
int score = 80;
String type = score<60?"及格":"不及格";
System.out.println(type); //及格

9、包机制：

• 为了更好地组织类，Java提供了包机制，由于区分类名的命名空间

• 包的语法格式：

package pkg1[.pkg2[.pkg3...]];

• 一般利用公司域名倒置作为包名；com.fs.www

• 为了能够使用一个包的成员，需要在Java程序中导入该包

• 参考：阿里巴巴Java开发手册

10、JavaDoc生成文档：

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

• 参数信息

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

• API文档：https://docs.oracle.com/javase/8/docs/api/

/**
 * @author fs
 * @version 1.0
 * @since 1.8
 */
public class Demo05 {
    String name;

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

生成doc文档

打开某个类所在文件夹下的cmd命令行
输入：javadoc -encoding UTF-8 -charset UTF-8 Doc(类名).java
会自动生成该类有关的API文档，查看文件夹发现多了一些文件
打开 index.html（首页）查看文档注释

视频学习地址：https://www.bilibili.com/video/BV12J41137hu?p=21