狂神说Java笔记-Java基础

Java基础

狂神说JAVA视频课笔记，狂神说JAVA

1. 注释

• 单行注释：//
• 多行注释：/* 注释 */
• JavaDoc文档注释注释：/** */
  • /**开头
  • */结尾
  • 每行开头一个*
  • 有关键字，自定义的关键字在帮助文档中是不显示的（如@Description，加了@反而不能在帮助文档显示，不如不加@）
  • JavaDoc标记
  • JavaDoc注释规范

public class Hello {
    public static void main(String[] args) {
        //单行注释
        System.out.println("Hello,World!");
        /*
        多行注释
        多行注释
         */

        //JavaDoc：文档注释 /**   */
        /**
         * Hello, world!
         * @author Dong
         */
    }
}

2. 数据类型

• 强数据类型：要求变量的使用要严格符合规定，所有变量必须先定义后使用。
  • 定义后不经过类型转换无法转换成其他数据类型。
  • 安全性高，速度慢。
• 弱类型语言

Java数据类型：

• 基本类型(primitive type)
• 引用类型(reference type)
  

基本类型

 Long类型要在数字后加L：long num=10L;，l和L都可以标识长整型，但l容易看成数字1，所以用L比较规范。

 float类型要在数字后加F：float num=10.1F;

 字符串String不是关键字，是类

引用数据类型

• 类
• 接口
• 数组

数据类型拓展及面试题

1. 整数拓展：

• 二进制：0b开头

• 八进制：0开头

• 十六进制：0x开头

  public class Demo1 {
      public static void main(String[] args) {
          int i=10;
          int i_2=0b10;//二进制 0b 开头
          int i_8=010;//八进制 0 开头
          int i_16=0x10;//十六进制 0x 开头
          System.out.println(i);
          System.out.println(i_2);
          System.out.println(i_8);
          System.out.println(i_16);
      }
  }
  

2. 浮点数拓展

银行业务中，钱怎么表示？

避免使用浮点数进行比较

浮点数是不精确的（有限的；离散的；有舍入误差的；大约；接近但不等于）

例子：

public class DataTypeDemo {
    public static void main(String[] args) 
        //浮点数
        float f=0.1f; //0.1
        double d=1.0/10; //0.1
        System.out.println(f==d);
        //期望输出true，但实际输出false

        float d1=1234424234523422342343421f;//这里数小了会输出false
        float d2=d1+1;
        System.out.println(d1==d2);
        //期望输出false，但实际输出true
    }
}

所以在遇到银行业务这类需要比较浮点数的情况，使用BigDecimal类(数学工具类)

3. 转义字符

• \t：制表符tab
• \n：换行

 转义字符

3. 类型转换

 在进行运算前，需要先将不同类型的数据转换成统一的数据类型

• 从高到低需要进行强制类型转换
  • 强制类型转换：（类型名）变量名
• 从低到高进行自动类型转换

 注意⚠️

1. 不能对布尔值进行转换

2. 不能把对象类型转换为不相干的类型

3. 在把高容量转换为低容量时，需要使用强制类型转换

4. 转换时可能出现内存溢出问题和精度问题

5. 字符型转换成整型时，转换成的是该字符的ascii码

   数字字符转换成整型时，要用该字符-‘0’：int number=‘4’-‘0’

public class TypeConversion {
    public static void main(String[] args) {
        //强制转换  高-》低
        int i=128;
        byte b=(byte)i;
        //内存溢出，byte存储范围[-128,127]

        System.out.println(i);
        System.out.println(b);//输出-128
        System.out.println("======================================");

        //======================================
        //自动转换  低-》高
        int ii=128;
        double bb=ii;

        System.out.println(ii);
        System.out.println(bb);//输出128.0
        System.out.println("======================================");

    }
}

溢出问题

  在进行数据的计算时，得到的数可能会出现溢出的问题。这时要先把进行计算的其中一个数转换为高容量的数据类型，然后在进行计算。

• 不能先计算再进行数据类型转换，因为计算完后的数的默认数据类型是原数据的数据类型，这样在进行数据类型转换前就已经溢出了

public class Overflow {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        int money = 10_0000_0000;//JDK7新特性，数字之间可以用下划线分割
        int year = 20;
        int total = money * year;//输出一个负数，计算的时候溢出的
        long totalLong = money * year;//先用原始的int类型计算完再转为long类型，所以转换之前已经出错

        //正确做法是在计算前先把一个数的数据类型转化为long类，再计算乘法
        long totalLongRight = money * ((long) year);
        System.out.println("用int储存的：" + total);//输出-1474836480
        System.out.println("用long储存但先计算的：" + totalLong);//输出-1474836480
        System.out.println("用long储存且先类型转换的：" + totalLongRight);//输出期望结果20000000000
    }
}

4. 变量、常量和作用域

变量

作用域

• 类变量（修饰符static）：static+数据类型+变量名
  • 可以不初始化
  • 可以在方法中直接调用
• 实例变量
  • 从属于对象，需要声明不需要初始化
  • 在方法中调用前，需要先将类实例化（新建一个对象）
• 局部变量
  • 必须声明和初始化值，只在方法内有效

public class Scope {
    //属性：变量

    //类变量 static，可以不初始化
    static double salary = 2500;

    //实例变量：从属于对象，需要声明不需要初始化
    // 实例变量不初始化的话，默认值为0  0.0
    //布尔值默认是false
    //除了基本类型，其余默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值，只在方法内有效
        int i = 10;

        Scope s = new Scope();
        System.out.println(s.age);//age没有初始化，但可以输出，输出为0

        System.out.println(salary);//类变量可以直接输出，输出2500

    }
    //其他方法
}

常量

 常量被初始化后不能再改变值

 修饰符为final（修饰符不去分前后）

 常量名一般全为大写

final 数据类型 常量名 = 值；
final double PI = 3.14;

4. 运算符

算术运算符

对于long、int、short和byte：

• 当进行运算的变量有long类型，则运算结果的数据类型为long
• 否则全部为int，即使是short和byte类型的变量，运算结果也是in

b=++a和b=a++：

• ++a：先自增，再给b赋值
• a++：先给b赋值，再自增

幂运算：

• Math.pow(底数，指数);

逻辑运算符

短路运算：

 当根据逻辑运算符前面的表达式就可以得出逻辑运算的结果时，逻辑运算符后面的表达式不再执行。

int c=5;
boolean d=(c<4) && (c++<4);
System.out.println(d);//输出false
System.out.println(d);//输出5

位运算

 位运算效率高

• &：与
• |：或
• ^：异或
• ~：非，取反
• <<：左移，相当于乘2
• >>：右移，相当于除以2

面试题：2*8=16，怎样运算最快

​ 答：用位运算最快

​ 0000 0001 1

​ 0000 0010 2

​ 0000 0100 4

​ 0000 1000 8

​ 0001 0000 16

​ 所以把2左移3，就可以得到16

System.out.printlin(2<<3);//输出16

扩展赋值运算符

• a+=b：a=a+b
• a-=b：a=a-b

字符串连接符 +

• 当+一边出现字符串类型时，运算返回的是字符串类型。运算符优先级不变，还是从左到右

System.out.printlin(""+1+2);//12
System.out.printlin(1+2+"");//3,先进行加法运算，再与字符串连接

三元运算符

• x ? y : z（掌握，常见）
  • 如果x==true，则返回y，否则返回z

5. 包机制

 包的本质就是文件夹

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

​ 防止命名空间重复

1. 在src里新建一个包

2. 取消compact middle packages

3. 可以在域名下加属于他的功能

包的导入

 为了使用其他包的成员，需要在java程序中使用import导入改包（idea可以设置自动导入包），导入的其他包的方法名不能和程序中的方法名一样。

​ .*为通配符，可以导入包下所有的类

​ import java.util.*

6. JavaDoc

​ 将注释信息生成自己的帮助文档/API文档

使用命令行生成帮助文档

1. 使用文档注释 /** */

2. 打开代码所在位置（mac：右键.java文件，点击Reveal in Finder）

3. 打开命令行,cd到代码所在文件夹，运行：

   javadoc -encoding UTF-8 -charset UTF-8 程序名.java

   -encoding utf-8 -charset utf-8 为了能够显示中文

4. 生成帮助文档

使用IDEA生成帮助文档

• Tools --> Generate JavaDoc

• 

• 参数：-encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” -link http://docs.Oracle.com/javase/8/docs/api