Java基础--数组和面向对象(Ⅰ)

数组前半部分
Java基础–面向对象(Ⅱ)

活动地址:CSDN21天学习挑战赛
不积跬步无以至千里

一.数组

1.数组中的基本应用(举例)
  • 最值问题 (最大值/最小值)
    •  已知一个数组,静态初始化,完成获取数组中最大值
      
    •  分析:
       *      int[] array = {65,45,76,87,13,36,98} ;
       *      定义一个参照物  array[0] 就是最大值
       *      从角标1开始遍历数组的其他元素
       *      判断:使用后面的元素依次和参照物比较
       *      如果后面元素比参照物,将最大值修改了
       *      最后获取最大值
      
public class ArrayDemo {
    public static void main(String[] args) {
        //创建一个数组静态初始化
        int[] array = {65,45,76,87,13,36,98};

        //赋值调用
        int max = getArrayMax(array) ; //实际参数
        System.out.println("max:"+max);

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

        //获取数组最小值
        int min = getArrayMin(array);
        System.out.println("min:"+min);
    }
    
      public static int getArrayMax(int[] arr){
        //定义参照物
        int max  = arr[0] ;
        //从角标1开始遍历数组,获取每一个元素
        for(int x = 1 ; x < arr.length ; x ++){
            //判断
            if(arr[x] > max){
                //将后面的元素赋值给max
                max = arr[x] ;
            }
        }
        return  max ;
    }

    //定义一个方法, 获取数组最小值
    public static int getArrayMin(int[] arr){
        //定义一个参照物 是最小值
        int min = arr[0] ;
        //从角标1开始遍历数组
        for (int i = 1; i < arr.length; i++) {
            //判断
            //如果后面的元素比min还小,后面的元素是最小值
            if(arr[i] < min){
                min = arr[i] ;
            }
        }
        return  min ;
    }
}

在这里插入图片描述

  • 数组查表法:
    •  给定一个数组,快速获取数组中的某个元素:数组名称[索引值]
      
    •  //字符串数组---里面存储字符串
      
    •  //创建数组的格式:静态初始化
      
    •  数据类型[] 数组名称 = {元素1,元素2,,..} ;
      
/**需求:
 *              键盘录入一个数据:
 *                      显示"星期"*/
import java.util.Scanner;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //键盘录入一个数据
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请您输入一个数字(0-6):") ;
        int num = sc.nextInt() ;

        String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
        System.out.println("你查询的星期是:"+strArray[num]) ;
    }
}
  • 数组逆序

    • 第一种

      public class Reverse {
          public static void main(String[] args) {
              //静态初始化数组
              int[] arr = {16,34,56,39,96,64,56,58,78,86};
              System.out.println("逆序前的数组:");
              printArray(arr);
              System.out.println("-------------------------------");
              System.out.println("逆序后的数组(方法1):");
              reverse(arr);
              printArray(arr);
              System.out.println("-------------------------------");
              System.out.println("逆序后的数组(方法2):");
              reserve2(arr);
              printArray(arr);
          }
          //遍历方法
          public static void printArray(int[] array){
              System.out.print("[");
              for (int i = 0;i < array.length ;i++){
                  if (i == array.length - 1){
                      System.out.println(array[i] + "]");
                  }else {
                      System.out.print(array[i] + ", ");
                  }
              }
          }
          //逆序1: arr.length / 2
          public static void reverse(int[] arr){
              for (int i = 0;i < arr.length / 2; i++){ //确定中间值
                 int temp = arr[arr.length - 1 -i];  //借助中间变量交换值
                  arr[arr.length - 1 -i] = arr[i];
                  arr[i] = temp;
              }
          }
      }
      

在这里插入图片描述

  • 第二种

     public static void reserve2(int[] arr){
            for (int start = 0,end = arr.length - 1;start < end;start++, end--){
                int temp = arr[end];
                arr[end] = arr[start];
                arr[start] = temp;
            }
        }
    

在这里插入图片描述

* 两次逆序又回到原数组

在这里插入图片描述

  • 数组中的基本元素查找法: 查询元素 的第一次出现的索引值,每次都需要从头查到尾

    • 对于基本元素查找法的----数组的元素的内容,可以无序/可以有序

      /* 需求:
       *  已知一个数组,静态初始化了,查询数组中某个元素的索引值;
       *
       *  int[] arr = {69,57,13,24,87} ;  //查询13这个元素第一次出现的索引值
       *                                      //133元素 */
      public class ArrayDemo3 {
      
          public static void main(String[] args) {
      
              //已知这个数组:
              int[] arr = {69,57,13,24,87} ;
      
              //调用方法
              int index = getIndex(arr, 13);//找13
              System.out.println("index:"+index);
              System.out.println("----------------------------") ;
              int index2 = getIndex(arr, 133);//找13
              System.out.println("index2:"+index2);
      
              System.out.println("-----------------------------") ;
      
              //调用
              int index3 = getIndex2(arr, 255);
      
              System.out.println("index3:"+index3);
              System.out.println("------------------------------");
              int index4 = getIndex2(arr, 87) ;
              System.out.println("index4:"+index4);
      
          }
          //方法1:
          public static int getIndex(int[] array,int target){//array:传递一个数组,target:查询目标元素
              //遍历数组,获取所有元素
              for(int x = 0 ; x < array.length; x++){
                  //array[x]:每一个元素就可以获取到
                  //如果array[x] 和target 相等,就找到了,x返回
                  if(target == array[x]){//考虑找到的情况
                      return  x ;
                  }
              }
              //查询数组:找不到元素,返回负数  -1
              return  -1 ;
          }
          //方式2:假设思想
          public static int getIndex2(int[] array,int target){
              //1)先定一个变量index:表示索引值
              int index = -1 ; //假设角标找不到
      
              //2)遍历数组array
              for(int x = 0 ; x <array.length ; x ++){
                  //获取到每一个元素array[x]
                  //如果 target  == array[x]:找到了,
                  if(target==array[x]){
                      //将index修改
                      index = x ;
                      break ;
                  }
              }
              return  index ;
          }
      }
      
  • 高级查询:二分搜索法(称为"折半查找):前提条件:数组的元素必须有序!

    • 特点:能够节省查询时间,效率高
2.排序算法之冒泡排序
  • 冒泡排序
    • 两两相互比较,将较大的值往后边放,第一次比较完毕,最大值出现在最大索引处;
    • 依次这样比较,可以得到排序好的数组;
    • 规律
      • 两两比较,将较大的值往后放,
      • 第一次有0个不比
      • 第二次有1个不比
      • 每次比较,就会减少一次比较 arr.length - 1 - x //x为比较的轮数,比较一轮少一人
      • 比较的次数:数组长度-1次 arr.length - 1
public class BubbleSort {
    public static void main(String[] args) {
        //静态初始化数组
        int[] arr = {16,34,56,39,96,64,56,58,78,86,98,89,87};
        System.out.println("冒泡排序前的数组:");
        printArray(arr);
        System.out.println("-------------------------------");
        System.out.println("冒泡排序后的数组:");
        bubbleSort(arr);
        printArray(arr);

    }
    //遍历方法
    public static void printArray(int[] array){
        System.out.print("[");
        for (int i = 0;i < array.length ;i++){
            if (i == array.length - 1){
                System.out.println(array[i] + "]");
            }else {
                System.out.print(array[i] + ", ");
            }
        }
    }
    //冒泡排序
    //每次比较,就会减少一次比较 arr.length - 1 - x      //x为比较的轮数,比较一轮少一人
    //比较的次数:数组长度-1次  arr.length - 1
    public static void bubbleSort(int[] arr){
        for (int x = 0; x < arr.length - 1; x++){//比较的次数:数组长度-1次  arr.length - 1
            for (int y = 0; y < arr.length - 1 - x; y++){//每次比较,就会减少一次比较 arr.length - 1 - x
                if (arr[y] > arr[y + 1]){
                    int temp = arr[y];
                    arr[y] = arr[y + 1];
                    arr[y + 1] = temp;
                }
            }
        }
    }
}

在这里插入图片描述

二.面向对象

1.面向对象(OO,Object Oriented)
  • 面向对象是软件工程中的一类编程风格,很多人称之为开发范式,而面向对象正是众多开发范式中的一种.在所有开发范式中,我们接触最多的还是面向过程与面向对象这两种.

    • 面向过程的程序设计(POP,Procedure Oriented Programming)

      • 一过程为中心的编程思想,其实自顶而下的编程模式,最典型的就是C语言
      • 在面向过程(PO,Procedure Oriented)的开发范式中,需要把问题分成一个个步骤,每个步骤用函数实现,再依次进行调用
    • 面向对象编程实现(OOP,Object Oriented Programming)

      • 在面向对象的开发范式在,将问题分解成一个个步骤,对步骤进行相应的抽象,从而形成对象,最终通过不同对象之间的调用来进行组合解决问题
2.类和对象
  • 类: 是能够描述现实世界事物一组属性和行为的集合
    • 类和事物的关系:一一对应的关系
  • 对象: 是类中所表示事物中的一个个个体,如:定义一个动物类,像大象、老虎、长颈鹿、狮子、狗等动物就是其中的一个个对象

注意:

  • 类中的成员变量:在类中方法外定义的变量

  • 类中的成员方法: 和这几天写的方法 定义学生的方法

  •    public 返回值类型 方法名(参数类型1 变量名1,...){
        		   //业务逻辑
                 return 结果;
       }
       public void 方法名(参数类型1 变量名1,...){
    
               //业务逻辑
               直接输出
       }
    
  • 举例

    //学生类:来描述现实世界真实的学生事物
    public class Student {
    
        //成员变量:类中方法外
        String name ; // 学生事物的属性 ----姓名
        String gender  ;//性别
        int age ; //年龄
        //学生的行为: 主要目的学习...
        public void study(){
            System.out.println("Good Good Study ,Day Day Up");
        }
    
    }
    
  • 补充:

    • 基本类型作为形式参数和引用类型(数组,类,接口)作为形式参数的特点
    • 基本类型作为形式参数:形参的改变不会实际参数;
    • 引用作为形式参数:形式参数的改变直接影响直接实际参数,除String类
    • 局部变量:生命周期:随着方法调用而存在,随着方法调用结束而结束;
    • String作为形式参数(引用类型),和基本类型作为形式参数是一样,形式参数的改变不会影响实际参数;

喜欢的可以点赞,谢谢大家
在这里插入图片描述

  • 2
    点赞
  • 0
    收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:游动-白 设计师:我叫白小胖 返回首页
评论

打赏作者

In-Deep

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值