自学Java的知识盲点（基础篇）

最新推荐文章于 2024-11-04 20:33:37 发布

海绵hong

最新推荐文章于 2024-11-04 20:33:37 发布

阅读量246

点赞数 1

分类专栏：二刷文章标签： java 开发语言 intellij-idea

本文链接：https://blog.csdn.net/weixin_54107527/article/details/124885057

版权

二刷专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.变量：

变量就是内存中的一块区域，我们可以把数据存储在变量中，通过变量可以获取到存进去的数据。```

int arr=100;

把100 存进了开辟的内存空间

1.1命名规范

1.给变量命名我们通常使用驼峰命名法即如果变量名由一个或者多个单词构成，第一个单词的首字母要小写，后面单词的首字母要大写

2.起名的时候要见名知意

1.2常量

在java中有一个值叫常量，变量的值可以发生变化，而常量的值不能发生变化，声明常量需要使用final关键字，常量的名字我们通常都是大写；

final int ARR=10;
ARR=11;//这个是错误的,会直接报错

2.数据类型转化

2.1自动类型转换注意和细节

1.有多种数据类型的数据混合运算时，系统首先自动将所有数据转化成容量最大的那种数据类型，然后在进行运算。

2.当我们把精度（容量）大的数据类型赋值给精度小的数据类型时，就会报错，反之就会进行自动类型转换。

3.（byte，short）和char之间不会相互自动转换

4.byte，short，char可以计算，在计算时首先转化为int类型

5.boolean不参与转换

6.自动提升原则：表达式结果的类型自动提升为操作数中最大的类型

2.2强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符 ( )，但可能造成

精度降低或溢出,格外要注意。

1.当进行数据的大小--由大变小，就需要使用强制类型转换

2.强转符号只对于最近的操作数有效，往往会使用小括号提升优先级

//int x=(int)11*3.5+6*1.5
int y=(int)(11*3.5+6*1.5)
System.out.println(y);

3.char类型可以保存int类型的常量值，但不能保存int类型的变量值，需要强制转换

4.byte，short，char类型在进行运算时，当作int类型处理

3.运算符

1.对于除号，它的整数除和小数除是有区别的，整数之间做除法时只保留整数部分，

double x=10/3;//x=3.0
  double x=10.5/3.2;
        System.out.println(x);x=3.28125

2.自增自减

没有参与运算的时候++，--，在前在后都没有区别，但是参与运算之后就会有本质区别

int a=3;
int b=a+++2;//b=5

因为在这个运算中，b会先参加这个+2的这个运算然后在自己+1，但是a的运算会将值先赋值给b

int a=3;
int b=++a+2;//b=6

3.赋值运算符

int a=3;
a+=2;//a=a+2

3.2案例（求四位数的和）

 System.out.println("请输入四位数");
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();
        int i1=i%10;
        int i2=i/10%10;
        int i3=i/100%10;
        int i4=i/1000%10;//1234/1000=1.234
        System.out.println(i1+i2+i3+i4);

3.3三元运算符

（条件表达式）？表达式1：表达式2；

如果条件表达式的结果为真就是执行表达式1，否则执行表达式2

     int a=(3>4)?30:40;
        System.out.println(a);//a=40

3.4^ 案例演示

a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

4.流程控制语句

4.1随机数类Random

方法1：

public int nextInt(int maxValue);
//产生0到maxValue的随机整数，包括0，不包括maxValue

方法2：

public double nextDouble();
//产生0到1之间的随机小数，包括0.0，不包括1.0

4.2if...else

这个应该都是没有啥需要注意的，注意到if（true）这个为真的时候执行花括号里面的，如果为假则跳出或者不执行

4.3switch

注意点：

1.表达式数据结构类型，应该和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int；

2.switch（表达式）中表达式的返回值必须是：（byte,short,int,char,enum[枚举]，String）

3.case子句中的值必须是常量，而不能是变量

4.default子句是可选的，当没有匹配的case时，执行default

5.break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序ui顺序执行到switch结尾，除非遇到break；

4.4switch 和 if 的比较

\1) 如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。

\2) 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围更广

4.5for 循环控制

\1) 循环条件是返回一个布尔值的表达式

\2) for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。

\3) 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代

语句，中间用逗号隔开

4.6while 循环控制

\1) 循环条件是返回一个布尔值的表达式

\2) while 循环是先判断再执行语句

4.7do..while 循环控制

基本语法

循环变量初始化

do{

循环体(语句);

循环变量迭代;

}while(循环条件);

注意点

\1. do while 是关键字

\1. 也有循环四要素, 只是位置不一样

\2. 先执行，再判断，也就是说，一定会至少执行一次

\3. 最后有一个分号 ;

4.8跳转语句break和continue

4.8.1break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环[for , while , do-while]中

//编写一个 main 方法
public static void main(String[] args) { 
    //1-100 以内的数求和，求出 当和 第一次大于 20 的当前数 【for + break】
    //思路分析
    //1. 循环 1-100, 求和 sum 
    //2. 当 sum > 20 时，记录下当前数，然后 break 
    //3. 在 for 循环外部，定义变量 n , 把当前 i 赋给 n 
    int sum = 0; 
    //累积和 
    //注意 i 的作用范围在 for{} 
    int n = 0; 
    for(int i = 1; i <= 100; i++) {
        sum += i;
        //累积 
        if(sum > 20) { 
            System.out.println("和>20 时候 当前数 i=" + i);
            n = i; break; } 
    }
    System.out.println("当前数=" + n);
}
}

4.8.2continue

\1) continue 语句用于结束本次循环，继续执行下一次循环。

\2) continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签的

使用的规则一样

5.数组

数组是一个变量，这个变量存储的是相同数据类型的一组数据

定义一个数组类型的变量相当于在内存中开辟了一块连续的空间

增强for遍历数组：只能访问数组中的元素，不能修改

int[] arr = {11, 22, 33, 44, 55, 66};
for(int i:arr){
        System.out.println(i);
}

数组使用注意事项和细节

\1) 数组是多个相同类型数据的组合，实现对这些数据的统一管理

\2) 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。

\3) 数组创建后，如果没有赋值，有默认值

int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null

\4) 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组

\5) 数组的下标是从 0 开始的。

\6) 数组下标必须在指定范围内使用，否则报：下标越界异常，比如

int [] arr=new int[5]; 则有效下标为 0-4

\7) 数组属引用类型，数组型数据是对象(object)

6.方法

6.1方法的调用机制原理：(重要!-示意图!!!)

提示：画出程序执行过程[getSum]+说明

只要调用一个方法就会产生一个新的栈

6.2成员方法的好处

\1) 提高代码的复用性

\2) 可以将实现的细节封装起来，然后供其他用户来调用即可

6.3引用数据类型的传参机制

引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！

6.4方法递归调用(非常非常重要，比较难)

简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变

得简洁

6.4.1递归重要规则

执行一个方法时，就创建一个新的受保护的独立空间（）栈空间
方法的举报变量是独立的，不会相互影响，比如int变量
如果方法中使用的是引用类型变量（比如数组，对象），就会共享该引用类型的数据
递归必须向退出递归的条件逼近，否则就是无限递归，出现异常
当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

练习：

汉诺塔传说：

汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，

在一根柱子上从下往上按照大小顺序摞着 64 片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一

根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

public class HanoiTower { 
    //编写一个 main 方法 
    public static void main(String[] args) { 
        Tower tower = new Tower();
        tower.move(64, 'A', 'B', 'C'); 
    } 
}
class Tower {
    //方法
    //num 表示要移动的个数, a, b, c 分别表示 A 塔，B 塔, C 塔 
    public void move(int num , char a, char b ,char c) {
        //如果只有一个盘 num = 1
        if(num == 1) {
            System.out.println(a + "->" + c);
        } else { 
            //如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1) 
            //(1)先移动上面所有的盘到 b, 借助 c move(num - 1 , a, c, b);
            //(2)把最下面的这个盘，移动到 c 
            System.out.println(a + "->" + c); 
            //(3)再把 b 塔的所有盘，移动到 c ,借助 a 
            move(num - 1, b, a, c);
        } 
    } 
}