[Java] 基础下半部分

紫妍快学习

已于 2023-02-17 02:23:01 修改

阅读量56

点赞数 2

文章标签： java jvm 开发语言

于 2023-02-10 00:46:00 首次发布

本文链接：https://blog.csdn.net/m0_74171760/article/details/128962256

版权

方法

方法（method）是将具有独立功能的代码块组织称为一个整体，使其具有特殊功能的代码集
1，方法必须先创建才可以使用该过程称为方法定义
2，方法创建后并不是直接可以运行的，需要手动使用后执行，该过程称为方法调用

方法定义与调用

方法定义：
格式：
public static void 方法名（）{
//方法体；
}
方法调用：
格式：方法名称（）；
范例：mayikt（）；
//方法必须先定义后才可以调用，否则程序将会报错
public static void main(String[] args) {
//main调用getMax方法
getMax();
}
/**
* 如何定义一个方法
* 方法名称。区分大小写
*/
public static void getMax(){
int a=20;
int b=30;
int max=-a>b?a:b;
System.out.println(“max:”+max);
}```java
常见错误：
1，在定义方法的过程中，不能够将方法定义在方法的里面
2 在这里插入图片描述
这是模拟了一个出栈进栈的过程

带参数的方法定义和调用

带参数的定义：
格式：public static void 方法名（参数){…}
单个参数：public static void 方法名（数据类型变量名称){…}
多个参数：public static void 方法名（数据类型变量名称，数据类型变量名称，。。。){…}
注意事项：
方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个都会报错
多个参数之间使用逗号分隔
带参数的方法调用：
格式：public static void getMax（int a, int b）{…}
带参数方法调用格式：方法名（参数）；
单个参数：方法名（变量名/常量值）
多个参数：方法名（变量名1/常量值1，变量名1/常量值1）
方法调用时，参数的数量和类型必须与方法定义中的设置相匹配，否则程序将报错

形参和实参

形参：方法定义中的参数
等同于变量定义格式，例如：int a；
实参：方法调用中的参数
等同于使用变量和常量例如：10，a，b
在这里插入图片描述

带返回值的方法和调用

带返回值方法定义格式：
public static 数据类型方法名（参数）{
return 数据
}
注意事项：
方法定义时return后面的返回值与方法定义上的数据类型要匹配
方法里面不能定义一个方法
void表示无返回值，可以省略return，也可以单独地书写return，后面不加数据

方法的重载

方法的重载指同一各类中定义的多个方法之间的关系，满足下列条件的多个方法构成重载
1，多个方法在同一各类中
2，多个方法具有相同的方法名
3，多个方法的参数类型不相同，类型不同或者数量不同

方法重载的特点
1，重载仅对应的方法的定义，与方法的调用无关，调用方法参照标准格式
2，重载仅针对同一各类中的名称与参数进行识别，与返回值无关，换句话说不能通过返回值类型来无关，换句话说不能通过返回值类型来判断两个方法是否构成重载

方法的参数传递基本类型

对于基本类型的参数，形参的改变，不会影响到实参数的值
请添加图片描述

出栈的流程

方法的参数传递引用类型

对于引用类型的参数，形参的改变，会影响到实参数的值

debug

debug是程序员使用的程序调试工具，用于追踪程序执行过程来调试程序
bug就是程序发生了错误
debug 操作流程
F8—调试当前的方法一步一步调试
F9—直接跳转到下一个断点
F7—直接调试进入方法里面–查看到细节
1，如何断点
选择要设置断点的代码行，在行号的区域后面点击鼠标左键即可
2，如何运行了断点的程序，在代码区域邮件debug执行

数组

java中的容器：数组，集合框架：在内存中对多个数据的存储
几个相关的概念
数组名
数组的元素（内部存储的多个元素）
数组的下标，角标，索引，index（即找到指定数组元素所使用的编号）
数组的长度（即数组容器中存储数据的个数）
2，数组的特点
数组中的元素在内存中是依次紧密排列的，有序的
数组，属于引用数据类型的变量。数组的变量，即可以是基本数据类型，也可以是引用数据类型
数组的分类
按照元素类型：基本数组类型元素的数组：引用数据类型元素的数组
按照数组的维数来分：一维数组，二维数组；

public class ch04 {
    public static void main(String[] args) {
        //定义两个数组
        int[] arr1={11,22,33,44,55};
        int[] arr2={11,22,33,44,55};
        boolean compare=compare(arr1,arr2);
        System.out.println(compare);
    }
    /**
     * arr1 数组1
     * arr2 数组2
     * 返回值是boolean  如果返回true
     * 则两个数组中的元素都是相同的 否则不相同
     */
    public static boolean compare(int[] arr1,int[] arr2) {

        boolean flag=true;
        //1，判断两个数组的长度是否一样
        if (arr1.length != arr2.length) {
            flag=false;
        }

        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                flag=false;
            }
        }
     return flag;
    }
}

flag是标志的意思，因为定义了返回值类型为boolean，返回值不一定返回true和false。写返回值对象就可以，两边都用static的原因是是由于静态方法只能调用静态，所以都要写。写返回类型。就一定写返回值
请添加图片描述

public static void main(String[] args) {
        //定义一个长度为6的数组  6位评委 为参赛选手打的分数
        int[] arr=new int[6];
        //键盘录入评委的分数并且存入到数组中
//        System.out.println("需要输入第一个评委打分的分数");
//        Scanner sc=new Scanner(System.in);
//        arr[0]= sc.nextInt();
//        System.out.println("需要输入第二个评委打分的分数");
//        arr[1]=sc.nextInt();
        Scanner sc=new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("需要输入第"+(i+1)+"个评委打分的分数");
            arr[i]=sc.nextInt();

        }
        int max = getMax(arr);
        System.out.println("max:"+max);
        int min = getMin(arr);
        System.out.println("min:"+min);
        int sum =getSum(arr);ss
        int avg = (sum-max-min)/arr.length-2;
        System.out.println("便利数组中的元素值");
        for (int i = 0; i < arr.length; i++) {
            System.out.println("i:"+arr[i]);
        }
    }

     /**
     * 传递一个数组给我
     * 该数组中的最大值
     * @param arr
     */
    public static int getMax(int[] arr){
        int max=arr [0];//默认情况下 先认为数组中的最大值是arr[0]；
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }
    public static int getMin(int[] arr){
        int min=arr [0];//默认情况下 先认为数组中的最大值是arr[0]；
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]<min){
               min =arr[i];
            }
        }
        return min;
        }
    public static int getSum(int[] arr){
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];

        }
        return sum;

    }

多维数组的使用

二维数组
请添加图片描述
二维数组的理解
对于二维数组的理解，可以看成是一维数组array1又作为另一个数组array2的元素而存在
从底层的运行机制来看，其实没有多维数组
静态初始化：数组变量的赋值和数组元素的赋值同时进行
int [ ] [ ] arr2 =new int[ ] [ ]{ { 1，2，3},{4，5 },{6，7 } }；
动态初始化：数组变量的赋值和数组元素的赋值分开进行
String[ ] [ ] arr3=new String [ ] [ ] ;

数组元素的调用
针对arr2来说，外层元素 int [ ] [ ] arr2 =new int[ ] [ ]{ { 1，2，3},{4，5 },{6，7 } }；
内存元素：1，2，3，4，5，6，7，8，9
调用内存元素
sout（arr2[0] [0]);//1
sout (arr2[2] [1]);// 7
调用外层元素
sout （arr2【0】；//地址。因为这个索引指向的是一维数组的地址指向的是一维数组所以才会显示的是地址
测试arr3,arr4

System.out.println(arr2[0][1]);
        System.out.println(arr3[0]);
        arr4[0] = new double[4];
        arr4[0][0]=1.0;

外层元素的默认值是地址值
内层元素默认值为null

数组的反转

 public static void main(String[] args) {
        int[] arr=new int[]{11,22,33,44,55,66,77,88};
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");

        }
        System.out.println();
        for (int i = 0; i < arr.length/2; i++) {
            //交互arr【i】与arr[arr.length-1-i]位置的元素
            //反转
            int temp =arr[i]; //相当于把arr[i]的值赋给temp就是把arr[i]的值放到temp的位置
            arr[i] =arr[arr.length-1-i];//arr.length-1-i相当于是传的第哪个位置上的值表示出来
                                        //因为是第0位所以要减1在减之前的
            arr[arr.length-1-i]=temp;//temp相当于一个媒介arr的值放到temp里面换位置然后再传回arr


        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }

数组的扩容

public static void main(String[] args) {
       int[] arr=new int[]{1,2,3,4,5};//这个长度为5
       //扩容1倍容量
       // int[]  newArr=new int[]{arr.length*2};
        //或
        int[] newArr=new int[arr.length<<1];//这个长度为10
        //将所有数组中的元素复制到新的数组中
        //用到arr是因为现在是用长度为5的
        for (int i = 0; i < arr.length; i++) {
            newArr[i]=arr[i];
        }
        //将10，20，30三个数据添加到新数组
        newArr[arr.length]=10;
        newArr[arr.length+1]=20;
        newArr[arr.length+2]=30;
        //将新的数组的地址赋值给原有的数组变量
        arr =newArr;
        //遍历arr
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }

数组的缩容

现有int[] arr={1,2,3,4,5,6,7}; 现需删除数组中索引为4的元素

就是不新建数组。后面的往前移动

public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6,7};
        int deleteIndex = 4;
        //不新建数组
        for (int i = deleteIndex; i < arr.length-1; i++) {
            arr[i]=arr[i+1];  //是后面的覆盖前面的所以需要减一
        }
        //修改最后元素
        arr[arr.length-1]=0;
        //遍历arr数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }

API

请添加图片描述

数组的使用中常见的异常小结
数组角标越界的异常：就是加入数组长度为4但是装进了长度为5的。就是角标越界
空指针异常
二维数组中的
出现异常会怎么样如何处理
一旦程序执行中出现异常程序会中止执行
针对于一场提供的信息修改对应的代码

面向对象

java类及类的成员：重点，属性，方法，构造器；熟悉代码块内部类
面向对象的特征。封装，继承，多台，抽象
其他关键字的使用：this，super，package，import，static，final，interface，abstract等
请添加图片描述

类

类时对现实生活中共同属性和行为等类的抽象
类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
类就是对现实事物的一种描述
手机-抽象的概念分类
对象属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值
简单理解：类是对事物的一种描述，对象则为具体存在的事物，类是兑现过的抽象，对象是类的实体
属性：品牌的名称
属性：品牌的价格
属性：品牌的规格
行为：拨打打电话
行为：发送短信

类的重要性

类是 java程序中重要的组成部分
类的组成：（属性和行为）
属性
在类中通过成员变量来体现（类种方法外的变量）
行为
在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤

定义类–手机小米等
定义成员方法变量–手机属于什么品牌价格
定义成员方法手机发送短信，手机拨打电话是属于行为具有动作行为
String brand ; brand属性名称 string 属性类型对象的使用
创建对象
格式：类名对象名 = new 类名（）；
范例：Phone phone1 = new Phone（）；
使用对象
使用成员变量
格式：对象名称.变量
范例：phone1.brand=“iPhone”；
phone1实际是个局部变量
通过对象名称.（调用到成员属性和成员方法）
使用成员方法
格式：对象名称.方法名
范例：phone.1.call();
psvm
Phone
面向对象完成具体功能的操作的三部流程
1:创建类，并设计类的内部成员（属性，方法）
2，创建类的对象，比如Phone p1 = new phone（）；
3，通过对象调用其内部生命的属性和方法，完成相关的功能

类的内部成员

一，属性，成员变量，field（字段，域）
二，（成员）方法，函数，method

类的实例化

等价描述：类的实例化《=》创建类的对象《=》创建类的实例
格式：类类型对象名 = 通过new创建的对象实例
eg：
Phone p1 = new Phone（）；
Scanner sc = new Scanner（System.in）;
String str = new String();

对象在内存中的分配涉及到的内存结构

栈：方法内定义的变量，存储在栈中
堆：new出来的结构（比如：数组实体，对象的实体）。包括对象的属性
方法区：存放类的模版。

创建类的对象
请添加图片描述

方法。method

权限修饰符（其他修饰符）返回值类型方法名（形参列表）（抛出异常）{
//返回体
}
权限修饰符
1，private 缺省（就是不写） protect public

返回值类型：描述当调用玩此方法是，是否需要返回一个结果
分类：
无返回值类型使用void
有具体的返回值类型，需要指明返回的数据类型，可以是基本数据类型，也可以是引用数据类型
需要在方法内部配合使用 return +返回值类型的变量和常量

方法名：属于标识符，见名知意

形参列表：形参，属于局部变量
格式：（形参类型1 形参1，形参类型2 形参2，。。。）
分类：无形参列表，有形参列表
无形参列表：不能省略一对（）。
有形参列表，需要的不确定的变量的类型和个数，无形参列表时确定形参的类型和个数

方法体：当我们调用一个方法时，真正执行的代码，体现了方法的功能

注意点：
java中的方法不能独立存在，所有的方法必须定义在类里
java中的方法不调用，不执行，没调用一次，就执行一次
方法内可以调用本类的方法和属性
方法内不能定义方法

return的作用
1，结束一个方法
2，结束一个方法的同时，可以返回数据给方法的调用者（方法声明中如果有返回值类型，则方法内需要搭配return使用）
不能有具体的执行语句

方法调用的内存解析
形参：方法在声明时，一对（）内声明的一个或多个形势参数

DAO接口
接口里写操作数据的方法
在写DAO接口的实现类
实现类里面写sql语句
如果返回值为一个对象调用DAO（工具类刁哥写的工具类）的get方法传sql传参
如果返回值为一个list集合用DAO（工具类刁哥写的工具类）的getforlist方法传sql传参
Dao层之后写test。service层不用test。
数据库被Dao操作，Dao被service调用。service被我们用