JAVA基础七

最新推荐文章于 2024-08-03 21:02:21 发布
最新推荐文章于 2024-08-03 21:02:21 发布
阅读量190 收藏
点赞数
分类专栏： Typora 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Small_Universe/article/details/126632134
版权

可变参数

  • JDK1.5开始，Java支持传递同类型的可变参数给一个方法
  • 在方法声明中，在指定参数类型后加一个省略号(…)
  • 在一个方法中只能指定一个可变参数，他必须是方法的最后一个参数。任何普通的参数必须在之前声明。
public static void printMax(double... numbers){
    if (numbers.length==0){
        System.out.println("NO arguement passed");
        return;
    }
    double result=numbers[0];
    //排序。
    for (int i = 1; i < numbers.length ; i++) {
        if (numbers[i]>result){
            result=numbers[i];
        }
    }
    System.out.println("This Max value is :"+result);
}

递归

  1. A方法调用B方法，我们很容易理解。
  2. 递归：简单来说就是写了一个方法，然后在方法里面调用这个写的方法。A方法调用A方法。
  3. 利用递归可以用简单的程序来解决一些复杂的问题。他通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
  4. 递归结构包括两部分：

  • ​ 递归头：什么时候不调用自身方法。如果没有头，程序会陷入死循环。

  • ​ 递归体：什么时候需要调用自身方法。

package com.Liu.method;

public class Demo06 {
	//递归思想
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    //5! 5*4*3*2*1
    public static int f(int n){
        if(n==1){
            return 1;
        }else{
            return n*f(n-1);
        }
    }
}

总结：

  1. 可变参数适用于接受多个参数的重载，但是可变参数是唯一的只能声明在普通参数的后面。
  2. 递归一般用于解决复杂的问题，它通过少量的代码可以解决重复计算，大大地减少了代码量。
  3. 递归函数的使用，必须要有开头，否则会使程序陷入死循环中。

数组

  • 数组是相同类型数据的有序集合
  • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
  • 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组的声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arryRefVar; //首选的方法
或
dataType arryRefVar[]; //效果相同，但不是首选方法  早些年为了方便C、C++的人快速掌握Java语言设定的定义方式

Java语言使用new操作符来创建数组，语法如下：

dataType[] arryRefVar =new dataType[arraySize];

数组的元素是通过索引访问的，数组的索引从0开始。

获取数组的长度：

arrays.length;

例：

package com.Liu.Array;

public class ArrayDemo01 {
    public static void main(String[] args) {
        //变量的类型  变量名字=变量的值
        //数组类型
        int[] nums;//1.声明一个数组
        int num02[]; //早些年为了方便C、C++的人快速掌握Java语言设定的定义方式

         nums =new int[10];//创建一个数组  这里面可以存放10个int类型的数字

        //给数组元素进行赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;

        //计算所有元素的和
        int sum=0;
        //获取数组的长度 nums.length
        for (int i = 0; i <nums.length ; i++) {
            sum=sum+nums[i];
        }
        System.out.println("总和为：sum="+sum);
    }
}

package com.Liu.Array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态变量初始化：创建+赋值
        int [] a={1,2,3,4,5,6,7,8};
        System.out.println(a[0]);
        
        //动态初始化
        int[] b=new int[10];
        b[0]=10;
        System.out.println(b[0]);
    }
}

数组的默认初始化

数组是引用数据类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

数组的四个基本特点

  1. 其长度是确定的，数组一旦被创建，它的大小是不可以改变的。
  2. 其元素必须是相同类型，不允许出现混合类型
  3. 数组中的元素可以是任意数据类型，包括基本数据类型和引用类型
  4. 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他类型，数组对象本身是在堆中的

数组下标越界

下标 的合法区间：[0,length-1],如果越界就会报错；

public static void main(String[] args) {
    //静态变量初始化：创建+赋值
    int [] a={1,2,3,4,5,6,7,8};
    System.out.println(a[0]);

    for (int i = 0; i <=a.length; i++) {
        System.out.println(a[i]);
    }
}

ArrayIndexOutOfBoundsException：数组下标越界异常！

小结：

数组是相同数据类型(数据类型可以是任意类型)的有序集合

数组也是对象。数组元素相当于对象的成员变量

数组长度是确定的、不可变的。如果越界，则报：ArrayIndexOutOfBounds

数组的使用

For-Each循环

数组作方法入参

数组作返回值

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组

int a[][]=new int[2][5];

    public  static void main(String [] args){
        //[4][2]
        /*
        1,2 array[0]
        2,3 arrya[1]
        3,4 array[2]
        4,5 array[3]
        */
        int[][] array={{1,2},{2,3},{3,4},{4,5}};
        for (int i = 0; i <array.length; i++) {
            for (int j = 0; j <array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
   }

Arrays类

数组的工具类Java.util.Arrays

由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。

查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而"不用"使用对象来调用（注意：是＂不用＂而不是＂不能＂）

具有以下常用功能：

**给数组赋值：**通过fill方法。

**对数组排序：**通过sort方法，按升序。

**比较数组：**通过equals方法比较数组中的元素是否相等

**查找数组元素：**通过binarySearch方法能对排序好的数组进行二分查找法操作。

冒泡排序

冒泡排序无疑是最为出名的排序算法之一，总共个有八大排序

冒泡的代码还是相当简单，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知。

我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度Ｏ(ｎ２)

package com.Liu.Array;

import java.util.Arrays;

//冒泡排序
//1。比较相邻的两个元素，如果第一个数比第二个数大，我们就交换他们的位置
//2.每一次比较，都会产生一个最大，或者最小的数字。
//3、下一轮则可以少一次排序
//一次循环知道结束
public class ArrayDemo07 {
    public static void main(String[] args) {
        //定义一个数组变量
        int a[]={1,4,7,2,66,12,33,77,61,88,9,10};
        //定义一个调用完我们自己写的排序方法后，返回一个排序后的数组变量用来接受a数组
        int[] sort=sorts(a);
        System.out.println(Arrays.toString(a));

    }


    public static int[] sorts(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {
            //通过flag标识位减少没有意义测比较
            boolean flag =false;
            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j+1]<array[j]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return array;
    }
}

稀疏数组

需求：编写五子棋游戏中，有存盘退出和续上盘的功能。

请添加图片描述

分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。0

解决：稀疏数组

稀疏数组的介绍

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式是：

记录数组一共有几行几列，有多少个不同的值

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模，

如下图：左边是原始数组，右边是稀疏数组

请添加图片描述

package com.Liu.Array;

import java.util.Arrays;


public class ArrayDemo08 {
    public static void main(String[] args) {
        //创建一个二维数组11*11 0:没有棋子 ；1：黑棋 ；2：白棋
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("===================================");
        //转化为稀疏数组来保存
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数"+sum);

        //创建一个稀疏数组的数组
        int[][] array2=new int[sum+1][3];

        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;

        //遍历二维数组，将非零的值，存放在稀疏数组中
        int count=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+
                    array2[i][1]+"\t"+
                    array2[i][2]+"\t");
        }

        System.out.println("======================================");
        System.out.println("还原");
        //读取稀疏数组的值
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        //给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        //打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("========================================");

    }
}

面向对象编程

Java的核心思想是OOP(面向对象编程)

  1. 初识面向对象
  2. 方法回顾和加深
  3. 对象的创建分析
  4. 面向对象三大特性
  5. 抽象类和接口
  6. 内部类及OOP实战

面向过程&面向对象

面向过程思想

  • 步骤清晰简单，第一步做什么，第二步做什么…
  • 面向过程适合处理一些较为简单的问题

面向对象思想

  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。

但是具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

面向对象编程(Object-Oriented-Programming，OOP)

面向对象编程的本质就是：以类的方法组织代码，以对象的形式封装数据。

抽象

三大特性：

封装

继承

多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板。

方法回顾和加深

方法的定义

修饰符

返回值类型

break：跳出 SWTICH，结束循环 和return(代表方法的结束) 的区别

方法名：注意规范就OK(驼峰命名法) 简明知意

参数列表：参数类型，参数名…

异常抛出：

方法的调用：递归

静态方法

非静态方法

形参和实参

值传递和引用传递

this关键字

package com.Liu.OOP.Demo01;

import java.io.IOException;

//Demo01 类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {

    }
    /*
        修饰符 返回值类型 方法名(){
        //方法体
        return 返回值;
        }
     */
    //return 结束方法，返回一个结果
    public String sayHllo(){
        return "hello,world";
    }
    public void print(){
        return;
    }
    //
    public int max(int a ,int b){
        return a>b?a:b;//三元运算符！
    }

    //数组下标越界 ArrayIndexOutOfBounds

    public void readFile(String file)throws IOException{

    }
}

package com.Liu.OOP.Demo01;

import com.Liu.Tools.Tools;

public class Demo02 {
    public static void main(String[] args) {
        //静态方法 static
        //如果是用static修饰的方法
        // 可以直接用  类名.方法
        Student.say();

        Tools.PrintLine();
        //非静态方法
        //1.实例化这个类
        //2.对象类型 对象名=对象值；
        Student student =new Student();
        student.study();
    }

    //加了static修饰的方法是和类一起加载的
    public static void a(){
        //b();
    };
    //实例化之后才存在  对象创建之后存在的
    public void b(){

    };
}


package com.Liu.OOP.Demo01;

//学生类
public class Student {
    //静态方法
    public static void say(){
        System.out.println("学生说话");
    }
    //非静态方法
    public  void study(){
        System.out.println("学生学习了");
    }
}

package com.Liu.OOP.Demo01;

public class Demo03 {
    public static void main(String[] args) {
        //没有加static修饰的时候需要实例化类再.方法
        //实例化类.方法
        //实际参数与形式参数要保持一致！！
        new Demo03().add(1,3);
        //加了static修饰的方法直接 类名.方法
        Demo03.add(1,2);
    }

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

package com.Liu.OOP.Demo01;

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        Demo04.change(a);
        System.out.println(a);
    }
    //返回值为空
    public static void change(int a){
        a=10;
    }
}

package com.Liu.OOP.Demo01;

//应用传递：对象，本质还是值传递

//对象，内存！！
public class Demo05 {

    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.name); //NULL

        Demo05.change(person);

        System.out.println(person.name);//黄河
    }

    public static void change(Person person){
        //person是一个对象：指向--> Person person =new Person();
        // 这是一个具体的人，可以改变属性！！
        person.name="黄河";
    }
}
//定义一个Person类，有一个属性name
class Person{
    String name;  //NULL
}
妄痴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java】第三章_数组（下）
luzining的博客
05-10 304
【Java】第三章 数组（下） 例题1 得出一下代码提示的手机号 import java.net.BindException; public class ArrayDemo { public static void main(String[] args) { int[] arr = new int[]{8, 2, 1, 0, 3}; int[] index = new int[]{2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3};
java中的数组声明创建与使用
LoserCoder_的博客
08-07 1484
数组 数组的定义： 相同类型的有序集合 按照一定的先后次序排列而成 每一个数组元素通过下标来访问他们 注意： 长度是确定的，一旦被创建，它的大小就是不可变的，即长度不变 数组元素的数据类型相同，不允许出现混合类型，可以是java中的任何数据类型，包括基本数据类型和引用类型 .数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组 本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象 本身是在堆中的。 数组的声明和创建 声明数组 首
Java基础：数组操作
weixin_43460813的博客
01-04 124
现在要求定义一个数组的操作类（整形），有如下几个要求 1.该数组的大小由类创建对象的时候动态决定 2.数据保存，考虑数组大小问题 3.发现数组空间不足，进行数组长度的动态扩充 4.可以取得数组的全部数据，在这个基础上，扩展两个派生类。可以进行排序和反转 class Array{//定义一个专门进行数组的操作类 private int data [];//定义一个整形数组 private in...
java练习-数组02
Cui_Cherry的博客
03-12 407
2.数组的练习 2.1数组概述和定义格式说明及数组的动态初始化 数组:存储同一数据类型多个元素的容器。 定义格式: A:数据类型[] 数组名; B:数据类型 数组名[]; 举例: A:int[] a; 定义一个int类型的数组a变量 B:int a[]; 定义一个int类型的a数组变量 注意:效果可以认为是一样的,都是定义一个int数组,但是念法上有些小区别。推荐使用第一种。 ...
【Java从入门到精通】Java变量类型
RL2698853114的博客
02-12 962
静态变量的定义方式是在类中使用 static 关键字修饰变量，通常也称为类变量。以下实例中我们定义一个静态变量count。
js获取数组元素个数和对象成员数
calu的专栏
08-01 3万+
http://www.51-n.com/t-4080-1-1.html Javascript怎么得到数组长度(也就是数组的元素个数)? Javascript怎么获取对象的成员个数? 你肯定想到了array.length!? 那么我们来测试一下下面这个例子.         var a = [];         a[50] = 50
Java基础知识总结（2021版）
热门推荐
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
java 数组值是变量_java，值的传递问题，一个类，类中有成员变量是数组，比如int[] a，创建对象后如何调用数组中的元素...
weixin_39902608的博客
02-12 136
importjava.io.*;publicclassBatch{//回溯法处理批处理作业调度问题staticintn;//作业数int[]Order;//作业顺序int[]bestOrder;//最优的作业顺序staticintbestf=Integer.MAX_VALUE;;//...import java.io.*;public class Batch { //回溯法处理批处理作业调度问题s...
Java数组、格式化输出
Kanteroa的博客
10-30 923
珠海科技学院 Java面向对象程序设计实验02 T03数组、格式化输出 1. 一维数组，存放 `Fibonacci` 数列 2. 格式化输出 3. 一维字符串数组存放主菜单，使用二维字符串数组存放全部菜单项，并进行分行分列且对齐的格式化输出
Java方法
weixin_45608986的博客
02-07 165
1.定义方法 修饰符 返回值类型 方法名（参数列表）{ 方法体; } 访问修饰符： public等等… 返回值： 可以是void（表示无返回值）和任何数据类型 方法名： 如果由一个单词组成，这个单词都小写；若多个单词组成，第一个单词是全部小写，从第二个单词开始首字母大写。例如：myMethod 2.方法分类 无参无返回值方法 无参带返回值方法 带参无返回值方法 带参带返回值方法 2.1无参无...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 175
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 517
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 517
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 562
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
JavaSE面向对象进阶
qq_45348840的博客
07-30 480
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 978
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Spring-包扫描
Promise_J_Z
08-03 117
二次判断类是否可独立实例化对象，内部类或者接口，抽象类都会对应生成一个.class文件，但是这些文件部分是不能够实例化的，不可以生成bean，所以在生成BeanDefinition之前需要进行过滤判断。对扫描到的BeanDefinition进行赋值，但是此时只是将className赋值到BeanDefinition中，因为还没有创建该类。spring在启动的时候就会往includeFilters中加入component注解。判断当前类是否需要当作bean进行处理。
【SpringBoot】 定时任务之任务执行和调度及使用指南
ToBeMaybe_的博客
08-03 556
本文将着重介绍Spring中的TaskExecutor接口、TaskScheduler接口、Trigger接口以及Spring中定时任务的任务执行和调度以及开发中的正确使用姿势。
Java基础知识概览
"这篇文档是关于Java基础知识的英文教程，涵盖了Java语言的可移植性、安全性、健壮性，以及Java程序的结构、执行方式、应用程序与小程序的区别、语言元素如注释、声明、表达式、语句、垃圾回收机制和语义学等方面。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值