java基础

一、运算符

          赋值运算符            =     +=   -=   *=   /=    %=    从右边往左执行

          基本运算符            +     -      *      /    %

          逻辑运算符            &    &&    |     ||     ！    ^

          关系运算符           ==   !=     >    >=   <     <=   判断是否满足，返回true和false

           +作连接符            与字符串一起运算

          三元运算符         （条件表达式）？值1：值2；

       自增自减运算符        ++a  先加1在使用变量 ;  

                                        a++  先使用变量再加1

二、顺序结构

           由上到下执行

三、分支结构

    if语句

           可以判断条件来决定执行哪个分支                                    

  

    switch语句

           根据表达式的值来进行值匹配选择对应的分支执行

       

             break防止穿透

三、循环结构

           控制一段代码重复执行多次

for语句：

    

while语句：

​​​do while语句:

四、数据类型

四类八种：

      整数类型：

  byte：8 位有符号整数，取值范围 -128 到 127 。

  short：16 位有符号整数，取值范围 -32768 到 32767 。

   int：32 位有符号整数，取值范围 -2147483648 到 2147483647 。

   long：64 位有符号整数，取值范围 -9223372036854775808 到 9223372036854775807 。

浮点类型：

        float：单精度 32 位浮点数。

  double：双精度 64 位浮点数。

字符类型：

   char：16 位 Unicode 字符。

布尔类型：

        boolean：值为 true 或 false 

数据类型转换：

        自动数据类型转换：

        范围小的数据类型可以自动转换为范围大的数据类型。

        例如，byte 可以自动转换为 short、int、long；

       short 可以自动转换为 int、long；

      int 可以自动转换为 long；

      int 可以自动转换为 float；

      long 可以自动转换为 float；

      float 可以自动转换为 double。

byte b = 10;
int i = b;  // 自动将 byte 类型的 b 转换为 int 类型并赋值给 i

           强制数据类型转换：

在 Java 中，强制类型转换是指通过特定的语法将一种数据类型显式地转换为另一种数据类型。

强制类型转换的语法格式为：(目标数据类型)要转换的值 。

但强制类型转换可能会导致数据精度的丢失或数据异常。

int num1 = 256;
byte num2 = (byte) num1;  // 由于 byte 的取值范围是 -128 到 127，这里会发生数据截断

double num3 = 3.14;
int num4 = (int) num3;  // 小数部分会被直接截断，结果为 3

五、键盘录入技术

键盘导包三步走：

1.导包：import java.util.Scanner

2.创建一个新扫描仪对象：Scanner sc = new Scanner(System.in);

3.等待接收用户的数据：int age = sc.nextInt()；

4.String name= sc.next();

5.char ch = sc.next().charAt(0);

六、数值拆分技巧

int a=298;
int ge=a%10;
int shi=a/10%10;
int bai=a/10/10%10;

1.%的意义为取余

2.例如298%10的计算流程为298/10=29（整数与整数相除，不保存小数）

3.余数为8，这时取到的便是个位的数字

七、跳转关键词

1.break

（1）switch语句中：结束switch语句，防止出现case穿透
（2）循环语句中（搭配if使用）：结束循环

2.continue

   1.用于跳出当前循环的当此执行

八、一维数组的定义

特点：

1.引用型数据类型

2.数组中存放的数据类型必须一致

3.数组的长度再运行期间是不可以改变的

格式：

动态初始化：指定数组的长度 数据类型[] 数组名=new 数据类型[36];

动态初始化：                          数据类型 数组名[]=new 数据类型[36];

静态初始化：指定数组的内容 数据类型[] 数组名=new 数据类型[]{87,68,97.......}

静态省略化：数据类型[] 数组名{87,68,97.......}

可以拆分为两步，但静态初始化的省略格式不可以拆分

静态数组的输出方法：

int[] arr = {10, 20, 30};
System.out.println(arr);//直接打印输出数组名，输出的结果是当前数组的地址值
System.out.println(arr[0]);//要想输出数组中的元素值，用：数组名[索引值]

int num = arr[2];   //赋值输出
System.out.println(num);

动态数组的使用：

动态初始化因为没有具体的元素内容，所以是有默认值的；

int：默认值是0：
floot：0.0；
字符型：'\u0000'
布尔型：false；
引用型：null

1.首先定义一个动态数组，并确定其长度      int[] a = new int[3];

2.然后通过数据名+索引的方式对动态数组赋值   a[1]=20;

注意：对于未赋值的输出结果为数据类型的默认值

引用地址赋予：

定义a与b两个数组，a=b，将b的的引用地址给a，a和b就是两个完全一样的数组

int[] a={10};
int[] b={40};

a=b;

九、一维静态数组的长度与遍历

获取静态数组长度：数组名.length

遍历数组：将数组里边的元素挨个输出，利用循环语句体

for(int i=0;i<=a.length-1;i++){

      System.out.println(a[i]); }

十、数组常见问题

ArrayIndexOutOfBoundsException 索引越界

解决办法：检查数组的索引，看是否越界

索引值是从0开始，直到数组的长度-1为止

int[]a={20};
System.out.println(a[0]);
 
System.out.println(a[1]);

NullPointerException 空指针异常

数组在未初始化时不能使用

解决办法：正确对数组初始化

int[] a=null;
System.out.println(a[0]);

十一、二维数组的定义

二维数组初始化的三种方式

int[][] a = new int[3][4];  

int[][] b = new int[3][];

int[][] c = {{1,2},{2,3},{3,4,5}};

二维数组的数组名.length:里面包含的一维数组的个数

1.第一个方括号为二维数组中存在几个一维数组

2.第二个方括号为一维数组的长度

 System.out.println(a.length);     //一维数组的个数
 System.out.println(a[0].length);  //第一个一维数组的长度

System.out.println(a[0]);  //二维数组中第一个一维数组的地址

将一维数组添加到二维数组

String [][] array=new String[1][];
//将一维数组添加到二维数组中
String [] a = {"2301","21","赵寻","可爱的女大学生","任职班长"};
array[0]=a;  

int[][] c = new[3][];
int[][] c = {{1,2},{2,3},{3,4,5}};

直接为二维数组添加内容

int[][]a = new int[3][4];
a[0][0]=2;
a[2][3]=4;
a[1][2]=6;

2
		6
			4

                                                 为赋值地方也要占用一个地址

十二、方法的定义

 方法的格式：

   return    后面的返回值要和方法名前面的"返回值类型"相对应

   无返回值时方法名前面为void

访问权限 修饰符 返回值类型 方法名（参数类型 参数名字1.参数类型 参数名字2....）{
   方法体：
   return 返回值;
 }

调用方法：

调用：
* 1.单独调用：方法名（参数）
* 2.打印调用：System.out.println(方法名（参数）); 打印调用，将方法的结果打印显示出来
* 3.赋值调用：数据类型 变量名 = 方法名（参数）; 将方法赋值给变量，再去操作变量
*    1.public static void main(String[] args)  void空类型 固定的main方法，方法里面不能嵌套方法
     2.固定的一个程序方法

无返回值的方法

流程步骤：

1.运行main方法，找到main方法中a、b的值，输入到wuFan方法中

2.运行wuFan方法，输出其结果

1.如果一个方法无返回值，那么方法名前面的”返回值类型“就是void类型

2.如果一个方法无返回值，那么它只能使用单独调用，不能使用赋值调用和打印调用

有返回值的方法

返回值要和要返回的方法体的返回值一致

1.执行main方法，在main方法中找到sum方法

2.将main方法中定义a与b的变量输入到sum方法中

3.sum执行完方法后，使用return将计算后的值返回到main方法

有返回值可以将计算过程定义在普通方法中，无返回值可以将计算过程定义在main方法中，然后将计算结果返回到普通方法中，并将其输出

十三、方法的有参与无参

  1.比较方法的有参数和无参数

         有参数：方法的（）里面有内容：当一个方法需要一些数据才能完成任务的时候，就需要有参数。比如：计算两个数字相加，需要知道这两个数字具体是多少。

         无参数：方法的（）里面无内容，当一个方法不需要数据输入就能完成任务的时候，就不需要有参数。比如：打印固定十次hello world（无参数）

2.方法的重载

方法的重载：方法名相同，但那参数列表不一样

1.参数的个数不同：

2.参数的类型不同：比如sum(int a,int b) sum(double a,double b)

3.参数类型顺序不同：比如sum(int a,float b) sum(float a,int b)

注： * 1.方法的重载与参数名无关sum(int a,int b)or sum(int x,int y)

2.方法的重载与返回值类型无关

不构成重载
 public void method(int num) {
        System.out.println("整数: " + num);
    }
 int method2(int num) {
        return num;
    }

 public static double sum(int a,int b,int c)

3.方法的重载与方法体的内容无关

例：

public static int sum(int a,int b){
       return a+b;
   }
    public static int sum(int a,int b,int c) {
        return a + b + c;
   }

    public static void sum() {
        System.out.println("hello,world");
    }

    public static int sum(int a,int b,int c,int d) {
        return a + b +c +d;
   }

主类调用：

重载方法的方法名相同，为了准确的调用，故在调用是填好与形参相对应的实参

public static void main(String[] args) { 
 System.out.println(sum(4,6));
 System.out.println(sum(4,6,8));
 System.out.println(sum(4,6,8,7));
 sum();
}

十四、变量

        定义：在java中，变量可以分为实例变量，类变量(静态变量),和局部变量

       实例变量是属于类的每个实例（对象）的变量。每个对象都有其自己独立的实例变量副本，实例变量在类中定义，但不在任何方法内部。

        类变量（静态变量）使用 `static` 关键字修饰，它属于整个类，而不是类的某个特定实例，所有实例共享同一个类变量。

         静态变量可以使用对象名与类名进行调用

         为了符合良好的编程习惯，不建议使用对象名来调用

        局部变量是在方法、构造函数或代码块中定义的变量，其作用域仅限于定义它的代码块。

实例变量和局部变量的主要区别包括：

1. 存储位置：实例变量存储在对象所在的堆内存中；局部变量存储在方法的栈内存中。

2. 生命周期：实例变量随着对象的创建而存在，直到对象被垃圾回收；局部变量在方法或代码块执行时创建，执行结束后销毁。

3. 初始化：实例变量如果没有显式初始化，会有默认的初始值（如整数类型为 0，引用类型为 `null` 等）；局部变量在使用前必须显式初始化。

4. 访问权限：实例变量可以通过对象来访问；局部变量只能在其定义的代码块内访问。

总的来说，实例变量是变量的一种，是与类的对象相关联的特定类型的变量，而变量是一个更通用的概念，包括实例变量、类变量和局部变量等不同类型。