Java摆烂基础学习一

待我称王封你为后i 2023-09-28 17:54 12阅读 0赞

## 前言 ##

> 活动地址：[CSDN21天学习挑战赛][CSDN21]

*学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。各位小伙伴，如果您：  
想系统/深入学习某技术知识点…  
一个人摸索学习很难坚持，想组团高效学习…  
想写博客但无从下手，急需写作干货注入能量…  
热爱写作，愿意让自己成为更好的人…*

### 自我介绍 ###

三年工作经验的摆烂程序猿一枚。  
*程序员，他们想的是什么？他们想的永远都是技术，他们崇尚的也永远都是技术。*

### 创作计划 ###

1，机缘

> 1，看看别人的实战项目中的经验分享（有用的，好的，都存下来 欺骗自己都会了）  
> 2，日常学习过程中的记录（写点啥把，要不然总感觉看了跟没看一样）  
> 3，和同程序员们交流心得（死皮赖脸问问题）  
> …

2，收获

> 三周学习一遍java基础，记录下当前学习的精髓之处、总结自己学习所得和不懂之处

3，学习时间（时间是其次，主要是用心）  
周一至周五早上 8.30 点—早上11点  
周六日下午 3 点-下午 6 点

## 一、idea的基本使用 ##

### 1.1 idea的下载 ###

非官方 [https://pan.baidu.com/s/1jsaUW6b1SPfI6GiovF4cvw][https_pan.baidu.com_s_1jsaUW6b1SPfI6GiovF4cvw] 1pfk  
官方下载：[https://www.jetbrains.com/idea/][https_www.jetbrains.com_idea]

### 1.2 idea的快捷方式 ###

main/psvm 快速生成main
    	sout 快速生成System.out.print
    	Alt+Insert 生成代码(如get,set方法,构造函数等) 或者右键（Generate）
    	Alt+鼠标左键 整列编辑
    	Ctrl+Alt+V 补齐返回类型及变量
    	Ctrl+Alt+T 快捷代码块 try catch 等
    	Ctrl+Alt+O 优化导入的类和包
    	Ctrl+D 复制当前行到下一行
    	Ctrl+Y 删除一行
    	ALT + SHIFT + ↑↓ 上下移动当前代码
    	Ctrl+F/R 查找/替换
    	CTRL+ALT+L 格式化代码
    	CTRL+ALT+I 自动缩进
    	Ctrl + W 快速选中
    	Alt + ↑↓  上下方法快速跳转
    	Ctrl + Alt + Enter 在当前行之前插入一行
    	Shift + Enter 在当前行之后插入一行
    	CTRL + / 注释 [CTRL + SHIFT + / 取消注释CTRL + SHIFT + \]

### 1.3 Idea添加类注释和方法注释快捷方式 ###

[https://blog.csdn.net/qq\_40453972/article/details/125652662][https_blog.csdn.net_qq_40453972_article_details_125652662]  
![在这里插入图片描述][7aac653c667942598136cfc42194b3f3.png]

## 二、Java基础语法 ##

### 2.1 java的数据类型 ###

#### 2.1.1、数据类型的作用是什么？ ####

程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同  
数据类型的作用是指导JVM在运行程序的时候给该数据分配多大的内存空间

#### 2.1.2 Java中的数据类型包括两种： ####

> 1）基本数据类型  
> 2）引用数据类型【不细说】  
> –类  
> –接口  
> –数组 …

#### 2.1.3 八种基本数据类型常识 ####

![在这里插入图片描述][9ddd891411e34864b772d2f976994607.png]

> 对于上图有以下几点需要注意：
> 
> a. java八种基本数据类型分为**四类八种，四类分别为整型、浮点型、布尔型、字符型；八种分别为byte、short、int、long、float、double、boolean、char**；  
> b. java八种基本数据类型的**字节数:分别为1、2、4、8个字节**；1字节(byte、boolean)、2字节(short、char)、4字节(int、float)、8字节(long、double)；  
> c. 整数的默认类型为int，浮点数的默认类型为double；  
> d. 八种基本数据类型的包装类：**除了char的是Character、int类型的是Integer，其他都是首字母大写**  
> e. 关于值的范围问题，需要注意**char**类型是**无符号的**，不能为负，所以是**0开始**的；

整数型的**直接量**默认为int类型 浮点型的直接量默认为double类型  
    @Test
        public void d() {
        
            int a=100;//这个100就是直接量
            a=a+100;//但是这个a+100不是直接量
            double b=3.14;
        }

#### 2.1.4 类型转换 ####

##### a. 自动转换 #####

低类型的向高类型的转换(下图：顺着箭头的方向是可以自动转换的)  
![类型转换][405866ca26f54c00bb3be5bde66d21c2.png]

##### b. 强制转换 #####

高类型的向底类型转换，但可能会**数据溢出或者精度丢失**  
可能会出现的三种问题  
1.定义变量时出现的类型转换

@Test
        public void e(){
        
            long a=200;//200是直接量，默认为int类型这里是自动转换为弄类型
             
            /*long b=100000000000;*/
            //100000000000是个整数直接量，默认应该为int类型，但是超出了int类型的取值范围
             
            long c=1000000000000L;
            //在整数直接量后面将了一个L，表示该直接量不再默认为int类型，为long类型，所以没错
             
            /*float d=34.3;*/
            //浮点型直接量默认为double,double类型大，所以不能直接转换为float
             
            float e=34.3f;
            //在浮点数直接量后面加上一个f，表示该直接量不再默认为double，为float类型
        }

以上为几种正常的情况，但是有一种特殊的情况，就是int型直接量可以直接赋给byte、short、char类型变量，只要不超出变量类型的取值范围

@Test
        public void f() {
        
            byte a=100;
            short b=200;
            char c=100;//注意char类型是一种特殊的int类型，可以不用写成单引号括起来的
             
            /*byte d=128;直接量128超出了byte类型的取值范围*/
             
            /*char e=-1;直接量-1不在char类型的取值范围内*/
             
        }

1.  数据运算时的类型转换  
    （1）运算时，运算结果会向较大的类型转换

@Test
        public void g() {
        
            int a=3;
            double b=4;
            System.out.println(a+b);//输出7.0
             
            float c=3.2f;
            /*c=c+3.14; 编译错误,运算之后变为double类型*/  
        }

（2）特殊的：byte、short、char三种数据类型参与运算时，先一律转化为int类型；

@Test
    public void h() {
        
        byte a=3;
        byte b=4;
        /*byte c=a+b;
         * 编译错误,此处由于byte类型参与运算时，先直接转换为int类型，
         * 所以最后的结果也是int类型，但是得出的结果不能叫做int类型的直接量，所以编译错误
         * */
        int d=a+b;
    }

3.强制转换  
高等级转为低等级的时候，必须强制转换，但实际工作中不推荐使用强制转换，可能会失精度或数据溢出；

@Test
        public void j() {
        
            int a=128;
            byte b=(byte)a;
            System.out.println(b);//输出-128，出现了数据溢出
             
            double c=1.23;
            int d=(int)c;
            System.out.println(d);//输出1，精度丢失
        }

补充说明：不是只有强制转换的时候会出现数据溢出，例如下面这种情况

@Test
        public void k() {
        
            int a=10000000;
            int b=10000000;
            int c=a*b;
            System.out.println(c);//输出276447232，得到的结果超出了int类型的范围，数据溢出
        }

#### 2.1.5 对应包装类及使用 ####

java是一门面向对象的语言，但是8中基本数据类型不具备面向对象的特征，所以实际使用中很不便所以为java八种基本数据类型提供了对应的包装类。  
![在这里插入图片描述][921c537e70984574aabe11dafe6873e5.png]

> 对应包装类比较特殊的就是int对应的Integer和char对应的Character；  
> 对应包装类的直接父类：前6个由于是数，直接父类为Number，而后两个的直接父类就是Object类；

##### 2.1.5.1 valueOf()：将基本数据类型转换为对应包装类：静态方法 #####

参数为基本数据类型，返回包装类对象；  
参数为String字符串（Character类没有以String为 参数的该方法）,返回包装类对象；

@Test
        public void a() {
        
        /*1.参数为基本数据类型       
         * 作用：将基本数据类型转换为对应包装类 * */
            Integer i=Integer.valueOf(10);
            System.out.println(i);//输出10
         
        /*2.参数为String字符串时，
         * 作用：返回指定字符串值的包装类对象
         *  */
            Integer a=Integer.valueOf("100");
            System.out.println(a);//输出100
             
            Integer b=Integer.valueOf("100a")为
            System.out.println(b);//运行错误，字符串的值不少一个int类型的
             
        }

##### 2.1.5.2 parseXXX(String str)：将字符串装换为对应的基本数据类型：静态方法 #####

Character类没有该方法；  
作用：将字符串装换为对应的基本数据类型（注意此处和上面的valueOf方法返回值的不同）；

@Test
        public void b() {
        
            /*作用：将给定字符串装换为对应的基本数据类型
             * 前提是该字符串必须正确描述该基本数据类型表示的值*/
            int a=Integer.parseInt("100");
            System.out.println(a);//输出100
             
            int b=Integer.parseInt("100a");
            System.out.println(b);//运行错误，字符串的值不为int类型
                     
        }

##### 2.1.5.3 XXXValue()：将当前包装类对象转换为对应的基本数据类型：非静态方法 #####

因为是非静态方法，所以不能像上面两个方法用类名调用了；  
数字类的包装类（八种包装类中父类是Number的的六个类）才有该方法；  
作用：将当前包装类对象转换为对应的基本数据类型；

@Test
        public void c() {
        
            /*作用：将包装类对象转换为对应的基本数据类型*/
             
            Integer a=Integer.valueOf(100);//将基本数据类型转换为包装类对象
            int b=a.intValue();//将包装类对象转换为对应的基本数据类型
            System.out.println(b);//输出100
             
            Double c=Double.valueOf(2.33);
            double d=c.doubleValue();
            System.out.println(d);
        }

##### 2.1.5.3 自动拆箱与装箱 #####

该特性是编译器认可的，是在编译器自动将基本数据类型和包装类相互转换，节省了麻烦。  
自动拆箱 包装类——>基本数据类型 (原理是调用了xxxValue方法)  
自动装箱 基本数据类型——>包装类 (原理是调用了valueOf方法)

@Test
        public void d() {
        
            /*自动装箱：valueOf*/
            Integer i=123;//原理是 Integer i=Integer.valueOf(123);
             
            /*自动拆箱*/
            int i1=i+1;//原理是    int i1=i.intValue()+1;
             
            Integer a=123;
            Integer b=123;
            Integer c=a+b;
            /*原理为Integer c=Integer.valueOf(a.intValue()+b.intValue());*/
        }

通过**查看源码**，以Integer类的valueOf(int i)的源码为例

public static Integer valueOf(int i) {
        
           if (i >= IntegerCache.low && i <= IntegerCache.high)
               return IntegerCache.cache[i + (-IntegerCache.low)];
           return new Integer(i);
       }

关于源码的理解：**Integer类的valueOf(int i)方法首先会判断i是否在-128~127之间，如果在的话，就返回的对象是Integer类中静态数组cache中的对象，如果不是在这之间，就会重写创建一个新的对象。**  
通过查看其它类的该方法的源码之后，可以得到该表：

<table> 
 <thead> 
  <tr> 
   <th>包装类</th> 
   <th>valueOf(X i)返回对象的原则</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Byte</td> 
   <td>直接取，数组范围为（-128,127），且byte值的范围也是（-128,127）</td> 
  </tr> 
  <tr> 
   <td>Short</td> 
   <td>（-128，127）之间在数组中取，否则new</td> 
  </tr> 
  <tr> 
   <td>Integer</td> 
   <td>（-128，127）之间在数组中取，否则new</td> 
  </tr> 
  <tr> 
   <td>Long</td> 
   <td>（-128，127）之间在数组中取，否则new</td> 
  </tr> 
  <tr> 
   <td>Float</td> 
   <td>直接new</td> 
  </tr> 
  <tr> 
   <td>Double</td> 
   <td>直接new</td> 
  </tr> 
  <tr> 
   <td>Boolean</td> 
   <td>直接返回，不new</td> 
  </tr> 
  <tr> 
   <td>Character</td> 
   <td>0-127之间从数组中取，否则new</td> 
  </tr> 
 </tbody> 
</table>

## 三、相关题 ##

### a、类型转换 ###

注意一些喜欢忽视的类型转换

public static void main(String[] args) {
        
            int a=10;
            double b=3.4;
            System.out.println(a>b?a:b);
            System.out.println(a);
        }
    /*输出：10.0   10
    解析：这里是一个很容易让人不注意的类型转化，这里a与b参与了运算，
    所以类型向类型大的方向转化，10就变成了10.0，但是a本身是没有变化的*/

### b、+=的情况 ###

public static void main(String[] args) {
        
            short a=1;  //第一行
             a=a+1;     //第二行
             a+=1;      //第三行
    }
    /*第几行的代码会出错？
    答案：第二行会出错，由于a+1变为了int类型,而int类型不能直接赋值给short类型
    但是+=这种情况是特殊的，所以不会出错；
    */

### a、自动装箱 ###

包装类和基本数据类型比较时，只要值相等就相等

public static void main(String[] args) {
        
            Integer a1=127;
            Integer a2=127;
            int a3=127;
            Integer b1=128;
            Integer b2=128;
            int b3=128;
            System.out.println(a1==a2);
            System.out.println(a1==a3);
            System.out.println(b1==b2);
            System.out.println(b1==b3); 
    }
    /*输出：true true false true
    解析：自动装箱时采用valueOf方法，由于127在静态数组的范围内，所以不是new的，
    而128的两个引用是指向new出现对象的，所以第一个是true，第三个是false。
    而包装类和基本数据类型比较时，只要数值是相等的，就相等
    */

### d、char类型存储汉字 ###

char类型能不能存储一个汉字？为什么？

解析：能，char类型采用的是Unicode编码，Unicode编码包含汉字，所以char类型自然是可以存储一个汉字的

### e、浮点数精度问题 ###

public static void main(String[] args) {
        
            System.out.println(0.1*3==0.3);
            System.out.println(0.1*4);
    }
    /*输出：false 0.4
    解析：有些浮点数不能准确的表示出来，与整数相乘之后出精度丢失，常见为小数位含3的
    */

[CSDN21]: https://marketing.csdn.net/p/bdabfb52c5d56532133df2adc1a728fd
[https_pan.baidu.com_s_1jsaUW6b1SPfI6GiovF4cvw]: https://pan.baidu.com/s/1jsaUW6b1SPfI6GiovF4cvw
[https_www.jetbrains.com_idea]: https://www.jetbrains.com/idea/
[https_blog.csdn.net_qq_40453972_article_details_125652662]: https://blog.csdn.net/qq_40453972/article/details/125652662
[7aac653c667942598136cfc42194b3f3.png]: https://img-blog.csdnimg.cn/7aac653c667942598136cfc42194b3f3.png
[9ddd891411e34864b772d2f976994607.png]: https://img-blog.csdnimg.cn/9ddd891411e34864b772d2f976994607.png
[405866ca26f54c00bb3be5bde66d21c2.png]: https://img-blog.csdnimg.cn/405866ca26f54c00bb3be5bde66d21c2.png
[921c537e70984574aabe11dafe6873e5.png]: https://img-blog.csdnimg.cn/921c537e70984574aabe11dafe6873e5.png