java学习笔记之基础篇

数组

1.数组的定义和声明

数组（引用数据类型）即为多个相同类型数据按一定顺序排列形成的内容。并且用一个名字命名，通过编号的方式对这些数据进行统一管理。

数组组成

数组名
元素
下标、角标、索引
数组的长度：元素的个数
数组的特点：

有序
数组属于引用数据类型，而数组的元素既可以是引用，也可以是基本数据类型。。
数组的长度一旦确定，就不能修改。
创建数组对象会在内存中开辟一整块连续的空间。
数组的分类：

按照维数：一维、二维
按照数组元素的类型：基本数据类型、引用数据类型
一维数组的使用：

一维数组的声明和初始化
如何调用数组的指定位置的元素
如何获取数组的长度
如何遍历数组
数组元素的默认初始化值
数组的内存解析

public class shuzu1 {
    public static void main(String[] agrs) {
//        一维数组的声明和初始化
        int[] num; //声明
        //静态初始化：数组的初始化和数组元素的赋值同时进行
        num = new int[]{1001, 1002};
        //动态初始化：数组的初始化和数组元素的赋值分开进行
        String[] names = new String[5];

        //错误的写法
        //int[] arr1 = new int[];
        //int[5] arr2 = new int[5];
        //总结数组一旦初始化完成，长度就确定了。
//       这种写法也是正确的，类型推断
        int[] arr8 = {1,2,3,4};
//      2.如何调用数组的指定位置的元素:通过角标的方式调用
        names[0] = "kh";//从0开始
        names[1] = "ml";
        names[2] = "17";
        names[3] = "yt";
        names[4] = "mt";
//      names[5] = "mt"; 越界
//      3.如何获取数组的长度
        System.out.println(names.length);
//      4.如何遍历数组
//        System.out.println(names[0]);
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
//      5.数组元素的默认初始化值
//       整形数据元素默认为0;
//       char类型数据元素默认为0（ascii码）
//       boolean布尔型默认值是false
//        引用数据类型的默认值是null
        int[] arr = new int[5];
        for (int s = 0; s < arr.length; s++) {
            System.out.println(arr[s]);
        }
        System.out.println("*************");
        char[] arr1 = new char[5];
        for (int f = 0; f < arr.length; f++) {
            System.out.println(arr1[f]);
            System.out.println("----" + arr1[f] + "----");
        }
        System.out.println("*************");
        boolean[] arr3 = new boolean[5];
        System.out.println(arr3[1]);

        System.out.println("*************");
        String[] arr4 = new String[5];
        System.out.println(arr4[1]);
//      6.数组的内存解析
//        栈与堆的关系
    }
}

2.二维数组的创建

二维数组的创建

public class shuzu21 {
    public static void main(String[] args) {
//  1.二维数组的声明和初始化
        int[] arr = new int[]{1, 2, 3};//一维数组
//     静态初始化
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}};
//     动态初始化
        int[][] arr2 = new int[4][5];
        String[][] arr3 = new String[4][2];
        String[][] arr4 = new String[4][];
//       类型推断
        int[][] arr5 = {{1, 2, 3, 4}, {2, 4}};

//       2.如何调用二维数组的指定位置的元素
        System.out.println(arr1[0][2]);//3
        System.out.println(arr3[0][0]);//null
        arr4[0]=new String[4];
        System.out.println(arr4[0][0]);//如果不先定义，就为空指针

//       3.获取数组的长度
        System.out.println(arr5.length);//2
        System.out.println(arr5[0].length);//4
//       4.如何遍历二维数组(两层for循环）
        System.out.println("_____________");
        for(int i=0;i<arr5.length;i++){
            for(int j=0;j<arr5[i].length;j++){
                System.out.print(arr5[i][j]+"  ");
            }
            System.out.println();
        }

    }
}

二维数组的使用

public class shuzu22 {
    public static void main(String[] args) {
//  二维数组的使用
//  分为外层数组元素和内层数组元素
//
//  5.二维数组的元素默认初始值
      /* 写法一 int[][] arr = new int[4][3];
        外层元素初始化值为地址值
        内层元素初始化值等同一维数组类型
        写法二 String[][] arr2 = new String[4][];
        外层元素 初始化值为null
        内层元素初始化值为不能调用，否则报错
        */
        int[][] arr = new int[4][3];
        System.out.println(arr[0]);//[I@119d7047地址值
        System.out.println(arr[0][0]);//0
        System.out.println(arr);//[[I@776ec8df

        System.out.println("----------------");

        String[][] arr1 = new String[4][4];
        System.out.println(arr1[1]);//地址值
        System.out.println(arr1[1][1]);//null

        System.out.println("----------------");
        String[][] arr2 = new String[4][];
        System.out.println(arr2[2]);//null
//      System.out.println(arr2[2][1]);空指针异常
        /*
        6.二位数组的内存解析


        * */
    }
}

在这里插入代码片

3.数组练习

数组练习题

import java.util.Scanner;

public class szlianxi1 {
    public static void main(String[] args) {
//      1.读取学生个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生人数：");
        int number = scanner.nextInt();
//      2.创建数组存储学生成绩，动态初始化
        int[] scores = new int[number];
//      3.给数组中的元素赋值
        int max = 0;
        System.out.println("请输入" + number + "个学生成绩");
        for (int i = 0; i < scores.length; i++) {
            scores[i] = scanner.nextInt();
            /*if (max < scores[i]) {
                max = scores[i];可以先在此处求出最大值
            }*/
        }
//      4.获取数组中的最大值

        for (int n = 0; n < scores.length; n++) {
            if (max < scores[n]) {
                max = scores[n];
            }
        }


//      5.根据成绩输出成绩并且判定等级
        char level;
        for (int d = 0; d < scores.length; d++) {
            if (max - scores[d] <= 10) {
                level = 'A';
            } else if (max - scores[d] <= 20) {
                level = 'B';
            } else if (max - scores[d] <= 30) {
                level = 'C';
            } else {
                level = 'E';
            }
            System.out.println("student "+d+"score is "+" "+scores[d]+"grade is"+level);
        }
    }
}
练习题2 杨辉三角

public class szlianxi2 {
    public static void main(String[] args) {
        int[][] arr=new int[][]{{3,5,8},{12,9},{7,0,6,4}};
        int sum = 0;
        for(int i = 0;i<arr.length;i++){
            for(int j = 0;j<arr[i].length;j++){
                sum+=arr[i][j];
            }
        }
        System.out.println(sum);
//      杨辉三角
        //1.声明一个二维数组
        int[][] yanghui=new int[10][];
        //2.赋值
        for(int i=0;i<yanghui.length;i++){
            yanghui[i]=new int[i+1];
            //2.1给首末元素赋值
            yanghui[i][0]=yanghui[i][i]=1;
            //2.2给每行的非首末元素赋值
            if(i>1){
                for(int j=1;j<yanghui[i].length-1;j++){
                    yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
                }
            }
        }

        //3.遍历
        for(int i=0;i<yanghui.length;i++){
            for(int j=0;j<yanghui[i].length;j++){
                System.out.print(yanghui[i][j]+" ");

            }
            System.out.println();

        }
    }
}

在这里插入代码片

基础算法

简单了解基本算法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VyY8imHe-1650249893374)(data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==)]

数值操作

public class suanfa1 {
    public static void main(String[] args) {
//   算法考察：求最大值最小值平均数总和
//    [10,99]
//    (int)(math.random()*(99-10+1)+10)
        int[] arr = new int[10];
        for(int i = 0;i<arr.length;i++){
            arr[i]=(int)(Math.random()*(99-10+1)+10);
        }
//        遍历数组
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]+"  ");
        }
        System.out.println();
//      求最大值
        int maxvalue = arr[0];//不写0是因为可能存在负数存在
        for(int i = 1;i<arr.length;i++){
            if(arr[i]>maxvalue){
                maxvalue = arr[i];
            }
        }
        System.out.println("最大值为："+maxvalue);

//        求最小值
        int minvalue = arr[0];//不写0是因为可能负数存在
        for(int i = 1;i<arr.length;i++){
            if(arr[i]<minvalue){
                minvalue = arr[i];
            }
        }
        System.out.println("最小值为："+minvalue);

//       求总和
        int sum = 0;
        for(int i = 0;i<arr.length;i++){
            sum+=arr[i];
        }
        System.out.println("总和为："+sum);

//        求平均值
        double ave = 0;
        ave = sum/arr.length;
        System.out.println("平均值为："+ave);

    }

}
数值的赋值

public class suanfa2 {
    public static void main(String[] args) {
        /*
        修改arr2的值导致arr1的值发生改变
        是因为将arr1的值赋给了arr2
        而arr1中存放的是堆中的地址
        相当于c语言中的指针
        * */
//        建立arr1数组
        int[] arr1,arr2 ;
        arr1 = new int[]{2,3,5,7,11,13,17,19};
        for(int i = 0;i<arr1.length;i++){
            System.out.print(arr1[i]+"\t");
        }
        System.out.println();
//        给arr2数组赋值
//        不能称作数组的复制，相当于是一个快捷方式
       arr2 = arr1;
//        修改arr2中的偶索引元素，使其等于索引值
        for(int i=0;i<arr2.length;i=i+2){
            arr2[i]=i;
        }
        for(int i = 0;i<arr1.length;i++){
            System.out.print(arr1[i]+"\t");
        }
        
    }
}
数组的复制与反转、二分法查找、线性查找

```java
    public static void main(String[] args) {
        /*
        * 数组的复制
        *数组的反转
        * */
        //  建立arr1/arr2数组
        int[] arr1,arr2 ;
        arr1 = new int[]{2,3,5,7,11,13,17,19};
        for(int i = 0;i<arr1.length;i++){
            System.out.print(arr1[i]+"\t");
        }
        System.out.println("----------");

//        将arr1中的值复制到arr2
        arr2 = new int[arr1.length];
        for(int i = 0;i<arr1.length;i++){
            arr2[i]=arr1[i];
        }
//       打印arr2
        for(int i = 0;i<arr1.length;i++){
            System.out.print(arr2[i]+"\t");
        }
        System.out.println("------");
//      数组的反转方法一
//        for(int i =0;i<arr1.length;i++){
//          for(int i =0;i<arr1.length/2;i++){
//            int temp = arr1[i];
//            arr1[i]=arr1[arr1.length-i-1];
//            arr1[arr1.length-i-1]=temp;
//         }
//        数组的反转方法二
        for(int i = 0,j=arr1.length-1;i<j;i++,j--){
            int temp = arr1[i];
            arr1[i]=arr1[j];
            arr1[j]=temp;
        }
//        方法三是通过两个数组完成
//       for(int i = arr2.length-1;i>=0;i--){
//
//                arr1[arr2.length-i-1]=arr2[i];
//        }
        for(int i = 0;i<arr1.length;i++){
            System.out.print(arr1[i]+"\t");
        }
        System.out.println("---------");
//      数组的查找
//      线性查找
        boolean isFlag = true;
        int dest = 7;
        for(int i = 0;i<arr1.length;i++){
            if(arr1[i]==dest){
                System.out.println(i);
                isFlag = false;
                break;
            }
        }
        if(isFlag){
            System.out.println("不好意思没有找到");
        }
//     二分法查找：（所查找的数组必须有序）
        int dest1=5;
        int head = 0;
        int end = arr1.length-1;
        boolean isFlag1=true;
        while(head<=end){
            int middle = (head+end)/2;
            if(dest1==arr1[middle]){
                System.out.println("找到了"+middle);
                isFlag=false;
            }else if(arr1[middle]>dest1){
                end=middle-1;
            }else{//rr2[middle]<dest1)
                head=middle+1;
            }
        }
        if(isFlag){
            System.out.println("不好意思没有找到");
        }
//       排序算法

    }
}
数组的冒泡排序

public class bubble {
    public static void main(String[] args) {
        int[] arr = new int[]{12,2,3,56,45,23,67,42};
//        冒泡排序
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
//        boolean equals(int[] a,int[] b);

    }
}

面向对象

类

1. 创建与设计类

public class duixiang1 {
    /*一、设计类就是设计类的成员
     * 属性=成员变量=field=域
     * 方法=成员方法=函数=method
     * 创建类的对象=类的实例化
     * 二、类和对象的使用（面向对象思想落地的实现）
     * 1.创建类，设计类的成员
     * 2.创建类的对象
     * 3.调用对象的属性和方法
     * 三、创建类的多个对象，每个对象有自己独立的属性
     * 意味着，修改一个对象的属性a，不影响另外一个对象属性a的值
     * 四、对象的内存解析
     * 栈：局部变量、指向堆的地址 堆：实体、属性
     * */
    public static void main(String[] args) {
//        创建person类的对象
        Person p1 = new Person();
//        调用对象的结构：属性、方法
//        调用属性：”对象.属性“
        p1.name = "angela";
        p1.age = 13;

        System.out.println(p1.age);
//       调用方法：“对象.方法”
        p1.eat();
        p1.talk("chinese");
//        ***************************
        Person p2 = new Person();
        System.out.println(p2.name);//null
//        *****************
        Person p3 = p1;//将p1中存放的堆地址给了p3
        System.out.println(p3.name);
        p3.age=8;
        System.out.println(p1.age);//修改p3同时p1也会改变
    }
}

class Person {
    //      属性
    String name;
    int age = 1;
    boolean isMale;

    //      方法
    public void eat() {
        System.out.println("人可以吃饭");

    }
    public void talk(String language) {
        System.out.println("人可以说话，使用的是：" + language);

    }
}

2.类的属性的使用以及属性和局部变量的比较

public class duixiang2 {
    /*
     * 类中属性的使用
     *
     * 属性（成员变量） vs 局部变量
     * 1.相同点
     *   1.1定义变量格式相同
     *   1.2先声明，后使用
     *   1.3都有它对应的作用域
     *
     * 2.不同点
     *   2.1在类中声明的位置不同
     *   属性：直接定义在类的一对{}中
     *   局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部变量
     *   2.2关于权限修饰符的不同
     *   属性：可以在声明属性时，指明其权限，使用权限修饰符。
     *   常用的权限修饰符：private、public、缺省、protected--->封装性
     *   目前我们使用缺省
     *   局部变量不能使用权限修饰符
     *   2.3默认初始化值的情况
     *   属性：类的属性，根据其类型，都有默认初始化值
     *   数字型：0 String：null boolean：false
     *   局部变量：没有默认初始化值
     *   调用之前必须赋值
     *   2.4在内存中加载的位置
     *   属性：加载到堆空间
     *   局部变量：加载到栈空间
     *
     * */
    public static void main(String[] args) {
        User p1 = new User();
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.isMale);
        p1.talk("llf");
    }
}

class User {
    //    定义属性（成员变量）
    String name;
    int age;
    boolean isMale;

    //    定义方法
    public void talk(String xox) {//形参、局部变量
        System.out.println("我喜欢" + xox);
    }

    public void eat() {
        String food = "passion friut" ;//局部变量
        System.out.println("我们喜欢吃" + food);

    }
}

3.数组工具类

public class shuzugjl {
    public static void main(String[] args) {
        shuzugjl s = new shuzugjl();
        int[] arr = new int[]{1, 2, 4, 5, 44, 3, 46, 89};
        s.print(arr);
        System.out.println();
        int max = s.max(arr);
        System.out.println("数组的最大值是：" + max);
        int min = s.min(arr);
        System.out.println("数组的最小值是：" + min);
        int sum = s.getsum(arr);
        System.out.println("数组的总和是：" + sum);
        int ave = s.ave(arr);
        System.out.println("数组的平均数是：" + ave);
        s.reverse(arr);
        s.print(arr);
        System.out.println("****************");
        int[] cp =s.copy(arr);
        s.print(cp);
        System.out.println("**********************");
        s.sort(arr);
        s.print(arr);
        System.out.println();
        int dex =s.index(arr,4);
        if(dex>=0){
            System.out.println("已经查找到，索引为："+dex);
        }else{
            System.out.println("没有查找到");
        }

    }

    //    求数组的最大值
    public int max(int[] arr) {
        int m = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > m) {
                m = arr[i];
            }
        }
        return m;
    }

    //    求最小值
    public int min(int[] arr) {
        int m = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < m) {
                m = arr[i];
            }
        }
        return m;
    }

    //    求总和
    public int getsum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    //    求平均值
    public int ave(int[] arr) {
        return getsum(arr) / arr.length;
    }

    //         反转数组
    public void reverse(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) {
            int m = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] =m;
        }


    }

    //    复制数组
    public int[] copy(int[] arr) {
        int[] cp = new int[arr.length];
        for(int i = 0;i<arr.length;i++){
            cp[i]=arr[i];
        }
        return cp;
    }

    //    数组排序
    public void sort(int[] arr) {
        for(int i =0 ;i<arr.length-1;i++){
            for(int j = 0;j<arr.length-1;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
            }
        }

    }

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

    //    查找指定元素
    public int index(int[] arr, int dest) {
        for(int i = 0;i<arr.length;i++){
            if(dest==arr[i]){
                return i;
            }
        }
        return -1;//返回一个负数表示没有找到
    }
}

方法

1.方法的使用

方法的使用

public class fangfa1 {
    /*
     * 类中方法的声明和使用
     * 方法：描述类应该具有的功能
     * 比如：math类、
     * 1、举例
     * public void eat() {
     * public void sleep(int hour) {
     * public String getName() {
     * public String getNation(String nation){
     * 有无返回值 有无形参
     * 2、方法的声明：权限修饰符 返回值类型 方法名（形参列表）{
     *                          方法体
     *  }
     * 3、说明
     *  3.1权限修饰符
     *  private。public、protected、缺省--->封装性
     *  3.2返回值类型：有返回值vs没有返回值
     *      3.2.1
     *      如果有返回值，必须声明时候指定返回值类型，同时必须使用return关键字返回值
     *      如果没有返回值，声明时候必须用void，不用return，除非是“return；”表示方法结束
     *      3.2.2
     *      定义方法的时候是否需要返回值
     *  3.3方法名：属于标识符，遵循标识符的命名规则
     *  3.4形参列表：方法可以声明0、1、多个
     *      数据类型1 形参1，数据类型2 形参2……
     *  4 return的作用
     *      结束方法
     *      有返回值类型，结束并且返回值
     *      return关键字后面不能有执行语句
     *  5.方法的使用：
     *          可以调用属性或者方法
     *          不可以在方法中定义方法
     * */
    public static void main(String[] args) {
        Customer p1 = new Customer();
        p1.eat();

    }
}

class Customer {
    String name;
    int age;
    boolean isMale;

    //  方法
    public void eat() {
        System.out.println("菲菲20220414晚上吃了米线外卖");
        return;//表示方法结束，return之后不再有语句，相当于break
    }

    public void sleep(int hour) {
        System.out.println("菲菲今天睡了" + hour + "小时");
    }

    public String getName() {
        return name;
    }
    public String getNation(String nation){
        String info = "我的粉籍是"+nation;
        return info;

    }
}

2.方法练习1

方法的练习一

public class fangfalianxi1 {
    public static void main(String[] args) {
        Person1 p2 = new Person1();
        p2.name="Lucy";
        p2.age=23;
        p2.sex=1;
        p2.study();
        p2.showAge();
        p2.addAge(2);
        System.out.println(p2.age);
        p2.showSex();
    }
}
 class Person1 {
    String name;
    int age;
    /**
     * sex 1表示女 2表示男
     * */
    int sex;
    public void study(){
        System.out.println("studying");
    }
    public void showAge(){
        System.out.println(age);;
    }
    public int addAge(int i){
        age+=2;
        return age;
    }
    public void showSex(){
        if(sex == 1){
            System.out.println("女性");
        }else{
            System.out.println("男性");
        }
    }

}

3.方法练习2

方法练习2

public class fangfalianxi2 {
    public static void main(String[] args) {
        circle e =new circle();
        e.r=3;
        double s =e.mianji();
        System.out.println(s);
        e.area();

    }
}
class circle{
    double r;
    public double mianji(){
        double s = Math.PI * r*r;
        return s;
    }
    public void area(){
        double s = Math.PI*r*r;
        System.out.println(s);
    }


}

4.方法练习3

方法练习3

public class fangfalianxi3 {
    public static void main(String[] args) {
        fangfalianxi3 q = new fangfalianxi3();
//        方法一
//        int i = q.method();
//        System.out.println(i);
//        方法二
        System.out.println(q.method());
    }
//    public void method(){
//        for(int i = 0;i<10;i++){
//            for(int j=0;j<8;j++){
//                System.out.print("* ");
//            }
//            System.out.println();
//        }
//    }
public int method(){
    for(int i = 0;i<10;i++){
        for(int j=0;j<8;j++){
            System.out.print("* ");
        }
        System.out.println();
    }
    return 8*10;
}

}

5.方法练习4

方法练习4

public class fangfalianxi4 {
    public static void main(String[] args) {
//    声明一个student数组
        Student[] stus = new Student[20];
        for (int i = 0; i < stus.length; i++) {
//            给数组元素赋值
            stus[i] = new Student();
//            给属性赋值
            stus[i].number = i + 1;
//          年级1-6
            stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
//            成绩0-100
            stus[i].score = (int) (Math.random() * (100 - 0 + 1) + 0);
        }
//        遍历学生对象
        for (int i = 0; i < stus.length; i++) {
            System.out.println(stus[i].info());
//            System.out.println(stus[i].state+"  "+stus[i].score+"  "+stus[i].number);
        }
//      打印出3年级学生信息
        System.out.println("--------------");
        for (int i = 0; i < stus.length; i++) {
            if (stus[i].state == 3) {
                System.out.println(stus[i].info());
            }
        }

//      冒泡排序并且按照成绩遍历
        for (int i = 0; i < stus.length - 1; i++) {
            for (int j = 0; j < stus.length - 1 - i; j++) {
                if (stus[j].score > stus[j + 1].score) {
//                  交换的是数组对象
                    Student temp = stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                }
            }
        }
        System.out.println("--------------");
        for (int i = 0; i < stus.length; i++) {

                System.out.println(stus[i].info());

        }


    }

}

class Student {
    int number;//学号
    int state;//年级
    int score;//成绩

    //    显示学生信息的方法
    public String info() {
        return "学号：" + number + "," + "年级：" + state + ",成绩：" + score;
    }

}

6.方法的重载

方法的重载定义及使用

public class overload {
    /*方法的重载
    1.定义：在同一个类中，允许存在一个以上的同名方法，
           只要它们的参数个数或者参数类型不同即可。
     2.”两同一不同“：同一个类，同一个方法名
                   参数列表不同，个数不同或者类型不同
     跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
     3.通过对象调用方法时，如何确定某一个指定的方法
     方法名--->参数列表
    * */
    public static void main(String[] args) {
        overload p = new overload();
        p.getsum(1,2);
    }
    public void getsum(String s, int i) {
        System.out.println("*****");
    }

    //    这两种方法为两种不同的调用
    public void getsum(int i, String s) {
        System.out.println("0000000");
    }
    public void getsum(double s, double i) {
        System.out.println("-------------");
    }
    public void getsum(int i, int s) {
        System.out.println("********");
    }
    //    public int getsum(int i ,int s){
    //        return 0;
    //    }
    //    public void getsum(int m, int n) {
    //        return 0;
    //    }
    //    private void getsum(int m, int n) {
    //
    //    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B3jjtOhP-1650249893377)(data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==)]

2. 方法重载的小练习

public class overloadtest {
    public static void main(String[] args) {

    }
    public void mOL(int i){
        System.out.println(i*i);
    }
    public void mOL(int i,int j){
        System.out.println(i*j);
    }
    public void mOL(String i){
        System.out.println(i);
    }
    public int max(int i,int j){
       return(i>j)?i:j;
    }
    public double max(double i,double j){
        return(i>j)?i:j;
    }
    public double max(double f,double g,double h) {
        double max = (f>g)?f:g;
       return  (max>h)?max:h;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EByzLQqr-1650249893379)(data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==)]

方法的重载之可变形参的定义和使用

/*
1.可变个数形参的格式：数据类型...变量名
2.当调用可变个数形参的方法时，传入的参数可以是0/1/多个
3.可变个数参数方法与本类中方法名相同，形参不同的方法构成重载
4.可变个数参数方法与本类中方法名相同，形参类型相同的数组之间不构成重载
  换句话说二者不能共存
5.可变个数形参在方法的形参中，必须声明在末尾
6.个数个数形参在方法的形参中，最多只能声明一个
* */
public class overload3 {
    public static void main(String[] args) {
        overload3 o = new overload3();
        o.show(12);
        o.show("angela");
        o.show("miss", "y");//可以有多个参数
        o.show(new String[]{"A", "B", "C", "F"});
    }

    public void show(int i) {
    }

    //    public void show(String i){
//
//    }
    public void show(String... strs) {
        System.out.println("这是可变形参");
//        仍然用数组的方法调用
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
    }

    //    版本更新之后不再使用这种方式，但是仍然可以用等于上述方式
//    public void show(String[] strs){
//        System.out.println("这是可变形参");
//    }
    public void show(int i, String... strs) {
    }
//  Vararg parameter must be the last in the list
//  可变个数形参必须声明在最末尾
//    public void show( String... strs,int i,) {
//    }
}

7. 递归方法

/**
 * 递归方法的使用（了解）
 * 1、递归：一个方法体内调用它自身
 */

public class digui1 {
    public static void main(String[] args) {
//        方法一
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println(sum);
        System.out.println("-----------");
        digui1 d = new digui1();
        int sum1 = d.getsum(100);
        System.out.println(sum1);
        System.out.println("************");
        int value = d.f(10);
        System.out.println(value);
    }

    //   例1计算1-n之间的和
    public int getsum(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n + getsum(n - 1);
        }
    }

    //    例2计算1-n之间的乘积 n！
    public int getcj(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * getcj(n - 1);
        }
    }

    //    例3已知有一个数列:f(0) = 1,f(1) = 4,
//    f(n+2)=2*f(n+1) + f(n)，
//    其中n是大于0的整数，求f(10)的值。
    public int f(int n) {
        if (n == 0) {
            return 1;
        } else if (n == 1) {
            return 4;
        } else {
            return 2 * f(n - 1) + f(n - 2);
        }
    }

    //    例4 斐波那契数列
// 
//    计算斐波那契数列的第n个值，并且打印整个数列

}

匿名对象

匿名对象的定义和使用

/*匿名对象：没有显示的赋给一个变量名
匿名对象只能使用一次
* */
public class niming {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.sendEmail();
        p.playGame();
//      匿名对象
//        new Phone().sendEmail();
//        new Phone().playGame();
        new Phone().price = 1900;
//      上下不是同一个对象，是两个匿名对象
        new Phone().showPrice();//0.0
        Phonemall mall = new Phonemall();
        mall.show(p);
//        匿名对象的使用,此时调用的是同一个对象
        System.out.println("**************");
        mall.show(new Phone());
    }
}

class Phonemall {
    public void show(Phone phone) {
        phone.sendEmail();
        phone.playGame();
    }
}

class Phone {
    double price;

    public void sendEmail() {
        System.out.println("发送邮件");
    }

    public void playGame() {
        System.out.println("玩游戏");
    }

    public void showPrice() {
        System.out.println("手机价格为：" + price);
    }

}

变量的赋值

/*变量的赋值
如果变量是基本数据类型，此时赋值的是变量所保存的数据值
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值
* */
public class bianliangfuzhi {
    public static void main(String[] args) {
        int m = 10;
        int n = m;
        System.out.println("m="+m+",n="+n);
        n = 30;
        System.out.println("m="+m+",n="+n);
        System.out.println("******引用数据类型******");
        Order o = new Order();
        o.orderId = 888;
        Order o2 = o;
        System.out.println("o的id是"+o.orderId);
        System.out.println("o2的id是"+o2.orderId);
        o2.orderId = 1818;
//      o2指向的是和o一样的地址，所以修改o2也会改变o
//      引用类型的值不是null就是地址值
        System.out.println("o的id是"+o.orderId);//1818
        System.out.println("o2的id是"+o2.orderId);//1818
    }

}
class Order{
    int orderId;
}

值传递机制

/*
方法的形参的传递机制：值传递
1.形参：方法定义时，声明的小括号内的参数
  实参：方法调用时，实际传递给形参的数据
2.值传递机制
如果变量是基本数据类型，此时赋值的是变量所保存的数据值
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值
* */
public class zhicd1 {
    public static void main(String[] args) {
        int m = 30;
        int n = 20;
        System.out.println("m=" + m + ",n=" + n);
//        交换两个变量的值的操作
//        int temp = m;
//        m=n;
//        n=temp;
        System.out.println("*************");
        zhicd1 p = new zhicd1();
        p.swap(m, n);
        System.out.println("m=" + m + ",n=" + n);
    }
//    此时交换的是形参，并没有改变m和n本身的值
    public void swap(int m, int n) {
        int temp = m;
        m = n;
        n = temp;
    }

}

/**
 * 此时交换成功
 */
public class zhicd2 {
    public static void main(String[] args) {
        Data data =new Data();
        data.m = 10;
        data.n = 20;
        System.out.println("m="+data.m+",n="+data.n);
//      交换m和n的值
//        int temp = data.m;
//        data.m = data.n;
//        data.n = temp;
        zhicd2 y = new zhicd2();
        y.swap(data);
        System.out.println("m="+data.m+",n="+data.n);

    }
//    引用类型值将data的地址给了形参
    public void swap(Data data){
        int temp = data.m;
        data.m = data.n;
        data.n = temp;
    }

}
class Data{
    int m;
    int n;

}

值传递内存解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bNLKeZm4-1650249893381)(G:\biji\值传递.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-59KSdSWW-1650249893382)(G:\biji\值传递2.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZqHYMcvT-1650249893382)(G:\biji\值传递网红题.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dvwof1NP-1650249893383)(G:\biji\网红解法1.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cc89vw9H-1650249893384)(G:\biji\题2.png)]

因为char[]的方法返回一个遍历数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x8XUa5Ry-1650249893385)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-20220416210729440.png)]

练习6

/**
 * （1）定义个circle类，包含一个double型的radius属性代表圆的半径
 * 一个findarea（）方法返回圆的面积
 */
public class circle1 {
    double radius ;
    public double findArea() {
        return Math.PI * radius * radius;
    }
}

/**
 * （2）定义一个类PassObject，在类中定义一个方法printAreas()
 * 该方法的定义如下: public void printAreas(Circle c, int time)。
 * 在printAreas方法中打印输出1到time之间的每个整数半径值，
 * 以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
 */

public class passobject {
    public static void main(String[] args) {
        passobject p = new passobject();
        circle1 c = new circle1();
        p.printAreas(c,5);
        System.out.println("now radius is "+c.radius);
    }
    public void printAreas(circle1 c,int time){
        System.out.println("radius\t\tarea");
//        设置圆的半径
        for(int i =0;i<=time;i++){
            c.radius = i;
            System.out.println(c.radius+"\t\t\t"+c.findArea());
        }
        c.radius=time+1;//要求输出结果为6.0

    }
}