Day3 | Java基础

一、注释

书写注释是一个非常好的习惯，平时写代码要注意规范
Java中有三种：单行注释 //
       多行注释 /* /
       文档注释 /* */

二、标识符

1. 关键字

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

3. 注意：

• 所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（_）开始
• 首字符之后可以是字母（A-Z或者a-z）、美元符（$）、下划线（_）或数字的任何字符组合
• 不能使用关键字作为变量名或方法名
• 标识符是大小写敏感的
• 合法标识符示例：age、$salary、_value、__1_value
• 非法标识符示例：123abc、-salary、#abc
• 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音
  

三、数据类型

1. 强类型语言

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

2. 弱类型语言

3. Java的数据类型分为两大类

• 基本类型（primitive type）
• 引用类型（reference type）
  

4. 注：什么是字节

• 位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数

• 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示

• 1B（byte，字节）= 8bit（位）

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

  bit表示位	1bit=1位
  Byte是字节，通常用B表示	1B=8bit
  KB是千字节	1KB=1024B
  MB是兆字节	1MB=1024KB
  GB是吉字节	1GB=1024MB

四、数据类型扩展及面试题讲解

1. 整数拓展： 进制 二进制 八进制 十进制 十六进制

int i = 10;
int i2 = 010;   // 八进制
int i3 = 0x10;  // 十六机制
System.out.println(i);
System.out.println(i2);
System.out.println(i3);

2. 浮点数拓展：少去用浮点数进行比较

// BigDecimal  数学工具类
float f = 0.1f;
double d = 1.0 / 10;
System.out.println(f == d);    // 可以看到这里的输出竟然是false

float d1 = 23131312312312313f;
float d2 = d1 + 1;
System.out.println(d1 == d2);    // 这里的输出则是true

3. 字符拓展

char c1 = 'q';
char c2 = '王';
System.out.println(c1);
System.out.println((int) c1);    // 强制转换
System.out.println(c2);
System.out.println((int) c2);    // 强制转换
// 所有字符本质还是数字
char c3 = '\u0061';    // 表示的是a
System.out.println(c3);

4. 转义字符

// \t表示制表符
// \n表示换行
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

5. 布尔值扩展

boolean flag = true;
// 下面这两个if语句是一样的，我们要学会使用第二个，Less is More，代码要精简易读
if (flag == true) {}
if (flag) {}

五、类型转换

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

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

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

2. 运算中，不同类型的数据先转换为同一类型，然后进行运算

3. 强制类型转换

4. 自动类型转换

   public static void main(String[] args){
       int i = 128;
       byte b = (byte)i;   // 强制转换：(类型)变量名  从高到低
       double c = i;       // 自动转换：什么都不用写  从低到高
       System.out.println(i);
       System.out.println(b);   // 输出b为-128，因为已经超过它的最大值，会有内存溢出的问题，在转换时要尽量避免
       System.out.println(c);
       System.out.println((int)23.7);      // 会得到23，精度丢失
       System.out.println((int)-45.89f);   // 会得到45，精度丢失
   
       char d ='a';
       int e = d + 1;
       System.out.println(e);
       System.out.println((char)e);
   
   }
   

注意点：

• 不能对布尔值进行转换
• 不能把对象类型转换为不相干的类型
• 在把高容量转换为低容量时，强制转换
• 转换时可能会存在内存溢出或者精度问题

一个操作大数的例子：

public static void main(String[] args){
    // 操作比较大的数的时候，注意溢出问题
    // JDK7新特性，数字之间可以用下划线分割
    int money = 10_0000_0000;
    int years =20;
    int total = money * years;
    System.out.println(total);   // 输出是一个负数，因为计算的时候溢出了

    long total2 = money * years;
    System.out.println(total2);   // 默认是int，转换之前已经出问题了

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

    // 小写的l和大写的L，尽量用大写的L，小写的l有时候看着很像1
}

六、变量、常量、作用域

1. 变量

   （1） 变量就是可以变化的量

   （2） Java是一种强类型语言，每个变量都必须声明类型

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

   type varName [=value] [{,varName[=value]}];
   // 数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量
   

   注意：

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

   public static void main(String[] args){
       // int a,b,c;
       // int a=1,b=2,c=3;   尽量分开成三行来写，注重程序的可读性
       // int a = 1;
       // int b = 2;
       // int c = 3;
       String name = "wangrong";    // 注意英文的分号要记住写
       char x = 'X';
       double pi = 3.14;
   }
   

2. 常量

   （1） 常量（Constant）：初始化（initialize）后不能再改变值，它是不会变动的值

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

   final 常量名 = 值
   final double PI = 3.14
   

   （3）常量名一般使用大写字符

   public class Demo07 {
       static final double PI = 3.14;     // final这个修饰符，不存在先后顺序，放在前面后面都可以
       // final static double PI = 3.14;
       public static void main(String[] args){
           System.out.println(PI);
       }
   }
   

3. 作用域

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

   public class Variable{
       static int allClicks = 0;     // 类变量
       String str = "hello world";   // 实例变量
       public void method(){
           int i = 0;    // 局部变量
       }
   }
   

   public class Demo08 {
       // 属性：变量
   
       // 实例变量：从属于对象，如果不自行初始化，这个类型就会默认值
       // 所有的数值类型默认值一般是0(整数) 0.0(小数)
       // 字符串的默认值是u0000,就是16位的0
       // 布尔值的默认值是false
       // 除了基本类型，其余的默认值都是null
   
       // 类变量
       static  double salary = 2700;
   
       String name;
       int age;
   
       // main方法
       public static void main(String[] args){
           // 局部变量：必须声明和初始化
           int i = 10;   // i只能在这个大花括号内有用
           System.out.println(i);
   
           // 实例变量  变量类型 变量名字 = new Demo08();
           Demo08 demo08 = new Demo08();
           System.out.println(demo08.age);
   
           // 类变量 static
           System.out.println(salary);
       }
       // 其他方法
       public void add(){
           System.out.println(i);   // 这里运行就会提示找不到i
       }
   }
   

   4. 变量的命名规范

      • 所有变量、方法、类名：要见名知意

      • 类成员变量：首字母小写和驼峰原则，如monthSalary，lastName

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

      • 常量：大写字母和下划线，如MAX_VALUE

      • 类名：首字母大写和驼峰原则，如Person，GoodPerson

      • 方法名：首字母小写和驼峰原则，如run()，runRun()

七、运算符

1. Java语言支持如下运算符

   • 算术运算符：+，-，*，/，%，++，–

     public static void main(String[] args){  
         // 二元运算符
         // 算数运算符
         // Ctrl + D：复制当前行到下一行
         int a = 10;
         int b = 20;
         int c = 25;
         int d = 25;
         System.out.println(a+b);
         System.out.println(a-b);
         System.out.println(a*b);
         System.out.println(a/b);   // a，b都是整数类型，进行除操作，最后只会保留整数部分
         System.out.println(a/(double)b);    // 要使a/b能输出正确的结果，那可以使用强转，把int类型转为double
         System.out.println(a%b);   // 取余（模运算）
     }
     

     

     public static void main(String[] args){
         // 一元运算符：自增（++）和自减（--）
         int a = 4;
         int b = a++;    // ++在后面，先给b赋值，再对a进行自增
         System.out.println(a);
         int c = ++a;    // ++在前面，先对a进行自增，再将a赋值给c
         System.out.println(a);
         System.out.println(b);
         System.out.println(c);
     
         int d = 10;
         int e = --d;    // --在前面，先对d进行自减，再将d赋值给e
         System.out.println(d);
         System.out.println(e);
         int f = d--;    // --在后面，先给赋值，再将d进行自减
         System.out.println(f);
         System.out.println(d);
     
         // 幂运算：可以使用一个工具类来操作 Math.pow(a,b)，a表示底数，b表示几次幂
         double pow = Math.pow(2,3);   // pow = 2*2*2
         System.out.println(pow);
     }
     

   • 赋值运算符：=

     public static void main(String[] args){
         // 不同类型的加法
         long a = 123123123123123L;
         int b =123;
         short c = 10;
         byte d = 8;
         System.out.println(a+b+c+d);   // 返回的是long
         System.out.println(b+c+d);   // 返回的是int
         System.out.println(c+d);   // 返回的是int
     }
     

   • 关系运算符：>，<，>=，<=，==，!=instanceof

     public static void main(String[] args){
         // 关系运算符
         // 关系运算符返回的结果是布尔值：true 或 false
         int a = 23;
         int b = 95;
         System.out.println(a > b);
         System.out.println(a < b);
         System.out.println(a == b);
         System.out.println(a != b);
     }
     

   • 逻辑运算符：&&，||，！

     public static void main(String[] args){
         // 逻辑运算符：与（&&），或（||），非（！）
         boolean a = true;
         boolean b = false;
         System.out.println("a && b:"+(a&&b));   // 逻辑与运算（&&）：当两个变量同时为真时，结果才为true
         System.out.println("a || b"+(a||b));    // 逻辑或运算（||）：当两个变量有一个为真时，结果则为真
         System.out.println("!a:"+!a);    // 取反运算（！）：如果是真，则结果为假；如果是假，则结果为真
     
         // 短路运算
         int c = 5;
         boolean d = (c<4)&&(c++<5);
         System.out.println(d);
         System.out.println(c);
     }
     

   • 位运算符：&，|，^，~，>>，<<，>>>

     public static void main(String[] args){
         // 位运算符
        \*
         A = 00111100
         B = 00001101
         ++++++++++++++++++++++++
         A & B = 00001100    与：对应的两个二进制位同时为1才得1
         A | B = 00111101    或：对应的两个二进制位只要有一个1结果为1
         A ^ B = 00110001    异或：对应的两个二进制位同时为1时结果为0
         ~ B = 11110010      非：就是取反
     
         左移（<<）：二进制数左移一位相当于乘以2
         右移（>>）：二进制数右移一位相当于除以2
          **/
         System.out.println(2<<3);   // 2会转为二进制进行左移3位数的操作，就相当于 2*2*2*2 = 16
     }
     

   • 条件运算符：? :

     public static void main(String[] args){
         // 条件运算符（？：），也是一个三元运算符
         // x ? y : z  如果x=true，则结果为y，否则结果为z
         int score1 = 80;
         int score2 = 50;
         String type1 = score1 < 60 ? "不及格" : "及格";
         String type2 = score2 < 60 ? "不及格" : "及格";
         System.out.println(type1);
         System.out.println(type2);
     }
     

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

     public static void main(String[] args){
         // 赋值运算符
         int a = 10;
         int b = 20;
         int c = 30;
         a += b;    // a = a+b
         c -= b;    // c = c-b
         System.out.println(a);
         System.out.println(c);
     
         // 字符串连接符 + :在+号两边只要有一个操作数是String类型，那么就会把其他操作数都转换为String类型再进行连接
         System.out.println(""+a+b);   // 这里a+b在后面，会直接将每个操作数连接起来，所以会得到3020
         System.out.println(a+b+"");   // 这里a+b在前面，会先计算a+b的值，再将结果转换为String类型与“”连接，所以会得到50
     }
     

2. 运算符的优先级

Java语言中运算符的优先级分为14级，其中1级最高，14级最低

优先级	运算符	结合性
1	()、[]、{}	左结合
2	!、+、-、~、++、–	右结合
3	*、/、%	左结合
4	+、-	左结合
5	<<、>>、>>>	左结合
6	<、<=、>、>=、instanceof	左结合
7	==、!=	左结合
8	&	左结合
9	^	左结合
10	|	左结合
11	&&	左结合
12	||	左结合
13	? :	右结合
14	= 、+=、-=、*=、/=、%=	右结合

八、包机制

1. 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间（包的本质其实就是文件夹）

2. 包语句的语法格式为：

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

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

   例如：www.baidu.com 建包时应该变为 com.baidu.www

4. 为了能够使用一个包的成员，我们需要在Java程序中明确导入该包。使用import语句可以完成此功能

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

   (推荐：《阿里巴巴开发手册》)

   

九、JavaDoc生成文档

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

   用命令行生成文档：javadoc -encoding UTF-8 -charset UTF-8 Doc.java （-encoding UTF-8 -charset UTF-8这段代码就是为了让文章显示更好，让中文显示正常，显示不会出现乱码）

   

可以看到在文件夹下多出了很多文件，点开index.html文件就可以看到我们自己生成的文档

2. 用IDEA编写代码来生成API文档

   

   

   

   

3. 参数信息

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

注：JDK8帮助文档：Overview (Java Platform SE 8 ) (oracle.com)

注：资料来源参考遇见狂神说的课程[https://www.bilibili.com/video/BV12J41137hu/?spm_id_from=333.999.0.0&vd_source=51e338bc66714d1cb8adb07196bec5e5]