JavaStudy02

---

---

前言

JavaSE就是一种标准版，是Java语言的基础部分，Java衍生出来的各种框架（如Spring系列）各种产品都是基于JavaSE标准，JavaSE是Java向上发展的基础，Java任何高级产品的底层基础都是JavaSE，JavaSE如果学不好，理解不透彻，后面学习框架时就有如天书一般，所以JavaSE这部分的重要性是不言而喻的，希望各位初学者铭记。
主要包含内容：数据类型、基础语法、运算符、流程控制、数组、面向对象、常用类、异常处理、集合、IO流、多线程、反射、注解、解析、网络编程。

一、注释、标识符、关键字

1.注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
注释并不会被执行，是给我们写代码的人看的
注释分为单行注释（//）和多行注释/* */

单行注释

/**
 * @作者 赚钱买Audi
 * @日期 2022/8/23 14:18
 * @包名:PACKAGE_NAME
 * @类名: Demo01
 * @描述: 从入门到入土
 * @版本 1.0
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println("helloWorld");
//        在控制台输出helloWorld  
//      （//）就是单行注释符号，加在想要注释的内容前面
//        快捷键位Ctrl + /
     }
  }

多行注释

/**
 * @作者 赚钱买Audi
 * @日期 2022/8/5 9:05
 * @包名:com.wjh.fuXi02
 * @类名: Demo06
 * @描述: 从入门到入土
 * @版本 1.0
 */
public class Demo06 {
    public static void main(String[] args) {
        /*这种形式就是多行注释
        *通常用在一些需要注释较多内容的地方
        *快捷键为 Ctrl + Shift + /
         */
       }
      }

---

2.数据类型

Java关键字

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
标识符注意点
所有的标识符都应该以字母(A-Z或者a-z),美元符或者下划线开始
首字符之后可以是字母(A-Z或者a-z) ,美元符（$)、下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名。
标识符是大小写敏感的

合法标识符举例: age、$salary、_value、__1_value
非法标识符举例:123abc、-salary、#abc

public class Demo06 {
    public static void main(String[] args) {
    String  孤独的船 = "孤独的船";
    //也可以使用中文命名，但是一般不推荐使用

---

二、数据类型

强类型语言
🍉要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
🔷弱类型语言
🔷Java的数据类型分为两大类
🍉基本类型(primitive type)
🍉引用类型(reference type)

引用数据类型：类，接口，数组

统称为八大类型

1. 什么是字节

🔷位(bit)∶是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
🔷字节(byte):是计算机中数据处理的基本单位，习惯上用大写B来表示,
🔷1B (byte,字节) = 8bit(位)
🔷字符:是指计算机中使用的字母、数字、字和符号
🔷1bit表示1位,
🔷1Byte表示一个字节1B=8b。
🔷1024B=1KB
🔷1024KB=1M
🔷 1024M=1G
32位和64位意味着处理器一次能处理的最大位数。
而现在的32位处理器只支持安装32位系统，64位处理器却能同时支持安装32位和64位系统。

2.八大基本类型扩展

1.整数

代码如下（示例）：

public class Demo {
    public static void main(String[] args) {
        //整数拓展:  进制    二进制0b    十进制    八进制0     十六进制0x
        int one = 10;
        int two = 010;     //八进制0
        int three = 0x10;  //十六进制0x    0~9  A~F 16
        System.out.println(one);
        System.out.println(two);
        System.out.println(three);
        
         } 
     }

运行结果

2.浮点数

代码如下（示例）：

public class Demo1 {
    public static void main(String[] args) {
        //浮点数拓展？   银行业务怎么表示？  钱？
        //BigDecimal  数学工具类
        //float   长度有限  离散  舍入误差   大约 接近  但不等于
        //最好完全不使用浮点数进行比较

        float f = 01f;      //0.1
        double d =1.0/10;   //0.1

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

        float d1 = 23123455676776555f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2); //true
    }
}

运行结果

3.字符拓展

代码如下（示例）：

public class Demo2 {
    public static void main(String[] args) {
        //字符拓展？
        char c1 = 'a';
        char c2 = '中';

        System.out.println(c1);
        System.out.println((int)c1);   //强制转换

        System.out.println(c2);
        System.out.println((int)c2);   //强制转换

        //结论，所有的字符本质还是数字
        //编码  Unicode 表：（97=a  65=A）  2字节    0-65536字符    （Excel 2的16次方 = 65536）

        // U0000  ~ UFFFF     Unicode编码表示方式
        char c3 = '\u0061';   //转义
        System.out.println(c3);  //a

        //转义字符
        //    \t:空格   制表符
        //    \n：换行
        //.......
        System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");
    }
}

运行结果

4.ASCII码对照表

5.布尔值扩展

public class Demo3 {
    public static void main(String[] args) {
      //布尔值扩展
      boolean flag = true;
      if(flag == true){}    //新手
      if(flag){}          //老手
      //Less is more！  代码要精简易读
    }
}

---

三、类型转换

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

小数的优先级大于整数

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

1.强制类型转换

public class Demo5 {
    public static void main(String[] args) {
        int i = 128;
        // Byte   包装类底层最大值是127；
        byte b = (byte)i;   //内存溢出

        //强制装换  （类型）变量名   高——低
        System.out.println(i);
        System.out.println(b);
    }
}

运行结果

2.自动类型转换

public class Demo5 {
    public static void main(String[] args) {
        int i = 128;
        double b = i;

        //自动转换  低----高
        System.out.println(i);
        System.out.println(b);
    }
}

运行结果

3.注意重点

1．不能对布尔值进行转换
2．不能把对象类型转换为不相干的类型
3．在把高容量转换到低容量的时候，强制转换
4．转换的时候可能存在内存溢出，或者精度问题!

public class Demo5 {
    public static void main(String[] args) {
        //精度问题
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f); //-45
        System.out.println("----------------");
        //  a =97
        char c = 'a';
        int d= c+1;
        System.out.println(d);
        System.out.println((char) d);
    }
}

运行结果

4.扩展

public class Demo6 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性 ，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;  // -1474836480   计算的时候溢出了
        System.out.println(total);
        long total2 = money*years;
        System.out.println(total2); //-1474836480  money*years默认是int，转换之前已经存在问题了？

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

运行结果

---

四、变量、常量

1.变量

1.注意事项:

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

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

2.为什么要有变量

举例：你按照领导的需求写好了代码，把这些数字作为字面值常量写在上面

这个时候领导临时改主意了，你没办法，为了生活，只能重头照着改

可是，领导又改需求了，你痛定思痛，决定不用这该死的常量了
改用变量

变量：顾名思义，就是在程序运行的过程中可以改变的量

3.变量的使用

语法：数据类型 变量名 = 值;
根据变量名进行使用，可以输出，也可以修改值

public class Demo6 {
    public static void main(String[] args) {
        //int a,b,c;
        //int a=18,b=19,c=20;
        //程序可读性  不建议上面两种
        int age = 20;
        String name = "深情男人";
        double price = 13.14;
        System.out.println("今天"+age+"岁的"+name+"在超市买到了特价"+price+"元一斤的猪脚，回家做猪脚饭......");

运行结果

4.变量作用域

1.类变量

类变量（也叫静态变量）是类中独立于方法之外的变量，用static 修饰。（static表示“全局的”、“静态的”，用来修饰成员变量和成员方法，或静态代码块（静态代码块独立于类成员，jvm加载类时会执行静态代码块，每个代码块只执行一次，按顺序执行））。
成员变量（也叫“实例变量”、“域”）也是类中独立于方法之外的变量，不过没有static修饰。

2.实例变量

在类声明的内部但是在类的其他成员方法之外声明的
类的每个对象维护它自己的一份实例变量的副本。
定义在类中但在任何方法之外
当一个对象被实例化后，每个实例变量的值就跟着确定。
实例变量在对象创建的时候创建，在对象被销毁的时候销毁。
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false,引用性的变量默认值是null
变量的值可以在声明时指定，也可以在构造方法中指定。

3.局部变量

局部变量声明在方法、构造方法或者语句块中。
在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁，访问修饰符不能用于局部变量。
只在声明它的方法、构造方法或者语句块中可见，是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，须经过初始化，才可以使用。

代码参考

public  class Demo01 {
   static  int  allClicks= 0 ;
//    类变量  是由类 数据类型  变量名组成

    String  str = "hello World";
//       实例变量

    public void method(){
        int i = 0;
//        局部变量

public class Demo7 {
    //类变量  static
    static double salary = 2500;   //工资
    
    //实例变量：从属于对象；如果不自行初始化，这个类的默认值 0
    //布尔值：默认是 false
    //除了基本类型，其余的默认值都是 null
    String name;
    int age;
    //程序主方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型   变量名字 = new Demo7();
        Demo7 demo7 = new Demo7();
        System.out.println(demo7.age);
        System.out.println(demo7.name);

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

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

}

4.常量

🔷常量(Constant)初始化(initialize)后不能再改变值!不会变动的值。
🔷所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

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

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

public class Demo8 {
    //修饰符，不存在先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

5.变量的命名规范

🔷所有变量、方法、类名:见名知意
🔷类成员变量:首字母小写和驼峰原则: monthSalary
🔷局部变量:首字母小写和驼峰原则
🔷常量:大写字母和下划线:MAX_VALUE
🔷类名:首字母大写和驼峰原则: Man,GoodMan
🔷方法名:首字母小写和驼峰原则: run(), runRun)

---

五.运算符

java语言支持如下运算符：

1.算术运算符

注意事项：

/和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
整数操作只能得到整数，要想得到小数，必须有浮点数参与运算

代码实例

public class Demo1 {
    public static void main(String[] args) {
        //二元运算符
        //Ctrl + D :复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 22;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);
        //取余，模运算
        System.out.println(c%a); //  c / a   22 / 10 = 2...余2
    }
}

运行结果

代码实例

public class Demo2 {
    public static void main(String[] args) {
        long a = 123454347568L;
        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
    }
}

运行结果

2.++，–（一元运算符）

|

符号	说明
++，自增	++在左边，先++，后赋值，++在右边，先赋值，后++
- -，自减	- -在左边，先- -，后赋值，- -在右边，先赋值，后- -

代码实例

public class Demo4 {
    public static void main(String[] args) {
        //  ++  --  自增，自减，一元运算符
        int a = 3;

        int b = a++;  //执行完这行代码后，先给b赋值，再自增
        //隐藏代码 a++   a = a + 1; 
        System.out.println(a);
        //隐藏代码 ++a   a = a + 1; 
        int c = ++a;  //执行完这行代码前，先自增，再给b赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        
        //扩展：幂运算  2^3   2*2*2 = 8  很多运算，我们会使用一些工具类来操作！
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }
}

运行结果

3.赋值运算符

代码实例

public class Demo01 {

    public static void main(String[] args) {

        int a = 10;
         int b = 20;
        
         a+=b; // a = a+b
         System.out.println(a); //30
        a-=b; // a = a-b
         System.out.println(a); //10
        
         //字符串连接符 + ,String
         System.out.println(""+a+b); //1020 ""字符串在前面，会拼接 所以是1020
         System.out.println(a+b+""); //1020 ""字符串在后面，会运算后再拼接 所以是30
         }
 }

运行结果

注意事项：
扩展的赋值运算符隐含了强制类型转换

4.关系运算符:>，<，>=，<=，==，!= instanceof

注意事项：
关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把“==”误写成“=”。

代码实例

public class Demo3 {
    public static void main(String[] args) {
        //关系运算符的结果都是boolean类型，要么是true，要么是false。
        int a = 10;
        int b = 20;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
    }
}

运行结果

5.逻辑运算符:&&，||，!

代码实例

public class Demo5 {
    public static void main(String[] args) {
        //  与（and）   或（or）   非（取反）
        boolean a = true;
        boolean b = false;

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

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(c);
        System.out.println(d);
        //不理解  多敲几遍就理解了
    }
}

运行结果

6.位运算符:&，|，^，~，>>，<<(了解! ! ! )

代码实例

public class Demo6 {
    public static void main(String[] args) {
        /*  位运算
            A = 0011 1100
            B = 0000 1101
            -------------------------
            A&B = 0000  1100                    //  A与 B  上下比较，两个都为 1 才为 1 否则就是 0
            A|B = 0011  1101                    //  A或 B  上下比较 两个都为 0  才为 0 否则就是 1
            A^B = 0011  0001                    //  A亦或B 上下比较 两个位置相同  则为0  否则为 1
            ~B  = 1111  0010                    //  ~B取反 上下比较 取反即可

           -----------------------------------------
           2*8 = 16   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   左移3位
        System.out.println(16>>3);  //2   右移3位
    }
}

运行结果

注意：逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false

7.三元运算符 ？：

代码实例

public class Demo8 {
    public static void main(String[] args) {
        //   x ? y : z
        // 如果 x==true，则结果为 y，否则结果为 z
        // 必须掌握
        int score = 80;
        String type = score < 60 ? "不及格":"及格";
        System.out.println(type);
    }
}

 

运行结果

比较最大值

比较最大值
public class Demo9 {
    public static void main(String[] args) {
        int a = 20;
        int b = 15;
        int c = 30;
        //求三个变量的最大值
        int type;
        type = a>b ? a : b;
        int max =  type > c ? type : c;
        System.out.println("三个变量的最大值是："+ max);

        //---------------------------
        //方式二
        int sum = (a>b ? a : b) > (a>c ? a : c) ? (a>b ? a : b) : (a>c ? a : c);
        System.out.println(sum);
        }
      }  

运行结果

---

六、包机制、javaDoc

1.包机制

🔷为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
🔷包语句的语法格式为:

package一定要放在最上面

2.javaDoc

🔷javadoc命令是用来生成自己API文档的
🔷参数信息
🍉author 作者名
🍉version 版本号
🍉since指明需要最早使用的jdk版本
🍉param参数名
🍉return返回值情况
🍉throws 异常抛出情况

命令生成javaDoc文档！
javadoc -encoding UTF-8 -charset UTF-8
语法：javadoc 参数 java文件

使用IDEA产生JavaDoc文档
1.首先创建一个存放JavaDoc的文件夹

2.然后在IDEA中打开如下目录

3.接着在这里选择创建Demo1文件夹的位置
4.然后在Local行和编码集写下如下代码，即可设置为中文且防止了中文带来的乱码

5.点击"ok"后IDEA便会自动生成JavaDoc文档，注意下方的输入栏出现以下语句即代表生成完毕

6.接下来在Demo01文件夹中找到index.html文件（2021新版idea默认会自动打开）

7.打开后就会看到我们的JavaDoc文档了，会包含项目中的所有类和程序包。

---

总结