java 返回list对象中某个值 java返回对象数组

转载

mob64ca140d2323 2024-07-03 11:11:25

文章标签 java 返回list对象中某个值 java 数组 System 构造器 文章分类 Java 后端开发

文章目录

Java基础04

数组复习

Java内存
二维数组
Arrays类

面向对象

方法的定义
方法的调用
创建与初始化对象
构造器详解
封装
继承

Java基础04

数组复习

dataType[]arrayrefver = new datatype[arraysize];
int[] sb1=new int[10]//定义一个数组并采用动态初始化
int[] sb1={1,2,3};//静态初始化
man[] men = {new man(1,1),new man(2,2)};//静态初始化
arrays.length //获取数组长度，常见用于循环

Java内存

分为

堆：存放new的对象和数组、可以被所有的线程共享，不会存放别的对象引用
栈：存放基本变量类型（包含基本类型的具体数值）、引用对象的变量（会存放这个引用在堆里面的具体地址）
方法区：可以被所有的线程共享、包含了所有的class和static变量

二维数组

数组里面再嵌套数组

int a[][] = new int[2][5]//两行五列的数组

Arrays类

数组的工具类java,util.Arrays

imoport java.util.Arrays;
System.out.println(Arrays.toString(a));/打印数组全部内容
    
Arrays.sort(a);//数组进行排序
System.out.println(Arrays.toString(a));//并打印

import java.util.Arrays;
public class demo11 {
    public static void main(String[] args) {
        int[] sb1={456,4413,124,1234,7855};
        Arrays.sort(sb1);
        System.out.println(Arrays.toString(sb1));
    }
}
//自动排序且输出数组元素
//[124,456,1234,4413,7855]

查看JDK帮助文档
Arrays类中的方法嗾使static修饰的静态方法，在使用的时候可以直接使用类名
给数组赋值：通过fill方法
对数组排序：sort方法，升序
比较数组：通过equals方法比较数组中的元素是否相等
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

import java.util.Arrays;
public class demo12 {
    public static void main(String[] args) {
        int[] a={1212,65,46,431,34,464,8};
        int[] big=big(a);//调用完我们自己写的排序方法后，返回一个排序后的数组
        System.out.println(Arrays.toString(big));
    }
     //降序
    public static int[] sort(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断我们要走多少次
        for (int i = 0 ; i < array.length-1; i++){
            //内层循环，比较两个数，如果num1>num2，交换位置
            boolean flag = flase;//通过flag标识位减少没有意义的比较
            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 == flase){
                break;//优化结构，少算一步
            }
        }
        return array;
    }
     //升序
    public static int[] big(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断我们要走多少次
        for (int i = 0 ; i < array.length-1; i++){
            //内层循环，比较两个数，如果num1>num2，交换位置
            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;
                }
            }
        }
        return array;
    }
}//冒泡排序

import java.util.Arrays;
public class demo13 {
    public static void main(String[] args) {
        int[] sb ={121,214,5,1,2454,54,5454};
        Arrays.sort(sb);
        System.out.println(Arrays.toString(sb));
    }
}
//以上两种代码都为了实现同一功能，自动降序

//稀疏数组

面向对象

物以类聚，分类的思维模式，思考问题首先会解决需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索
面向对象适合处理复杂的问题，适合处理多人协作的问题
属性+方法=类
方法中写了return说明整个方法已经结束了
return 后的值必须后方法名前面的返回值类型相同

方法的定义

修饰符
返回类型
break
方法名
参数列表
异常抛出

方法的调用

静态方法
非静态方法
形参和实参
值传递和引用传递
this关键字

类是一种抽象的数据类型，他对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
对象是抽象概念的具体实例
能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

创建与初始化对象

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

类中的构造器也成构造方法，是在进行创建对象的时候必须要调用的。构造器有以下两个特点

1.必须和类的名字相同

必须没有返回类型，也不能写void

构造器必须要掌握

public class student{//创建学生类
    
}

package LEI;

public class DEMO01 {
    //属性：字段
    String name;
    int age;
    //方法：
    public void study(){
        System.out.println(this.name+"在学习");
    }
    //一个类中只可能存在属性和方法两个
}//创建类

package LEI;

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

        //类是抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //demo01对象就是一个DEMO01类的具体实例
        DEMO01 demo01 = new DEMO01();
        DEMO01 demo02 = new DEMO01();
        DEMO01 demo03 = new DEMO01();


        demo01.name="小明";
        demo01.age=18;

        System.out.println(demo01.name);
        System.out.println(demo01.age);

    }
}
//创建对象并赋值输出

构造器详解

一个类即是什么都不写，他也会存在一个方法
类中的构造器也成构造方法，是在进行创建对象的时候必须要调用的。构造器有以下两个特点

必须和类的名字相同
必须没有返回类型，也不能写void

构造器必须要掌握

public class person{
    String name;
    
    //实例化初始值
    //构造器的作用：1.使用new关键字，本质就是在调用构造器
    public Person(){
        
    }
    
    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
    
}

package lei2;

public class Person {
    String sbname;
    int sbage;

    public Person() {
    }

    public Person(String name23 , int age11){
        this.sbname=name23;
        this.sbage=age11;
    }
}//创建类

package lei2;

public class Application {
    public static void main(String[] args) {
        Person person1 = new Person("sb",23);


        System.out.println(person1.sbage);
    }
}//调用类

封装

高内聚，低耦合。
高内聚就是类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部使用
封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏

属性私有，get/set

可以在封装的时候做一些检查

//类
public class student {

    private String name;//private:私有的
    private int id;
    private char sex;


    //获得这个数据
    public String getName(){
        return name;
    }
    //设置数据
    public void setName(String name){
        this.name = name;
    }
}

public class application {
    public static void main(String[] args) {
        student s1 = new student();

        s1.setName("nb");

        System.out.println(s1.getName());
    }
}

继承

子类继承了父类，就拥有父类的所有方法

//基类，父类
public class person {

    public void say(){
        System.out.println("");
    }
}

//学生 is 人   :派生类，子类
public class student extends person {
}

public class application {

    public static void main(String[] args) {
        student s1 = new student();

        s1.say();

    }
}

//public
//protected   权限比defalut高
//defalut
//private
//ctrl+h  打开继承树（前提在父类文件下）

在Java中，所有的类，都默认直接或者继承object
Java中类只有单继承，没有多继承
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等

super

可以与this进行对比

public class student extends person{
    prtvate String name ="sb1";
    
    public void test(String name){
        System.out.printin(neme);//传递给输出的name
        System.out.printin(this.name);//输出类里面的
        System.out.printin(super.neme);//父级的
            
    }
}

public class person{
    protected String name = "sb2";
   
}

super注意点：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法总
super和this不能同时调用构造方法

代表的对象不同：

this：本身调用着这个对象

super：代表父类对象的引用

前提

this：没有继承也可以使用

super：只能在继承条件下才可以使用

构造方法

this（）：本类的构造

super（）：父类的构造

方法重写

重写都是方法的重写，与属性无关
需要有继承关系，子类重写父类的方法

重写：

方法名必须相同
参数列表必须相同
修饰符：范围可以变大public>protected
抛出的异常范围可以被缩小，但不能扩大

classnotfoundexcepttion 类找不到

exception范围大

重写 子类的方法和父类必须要一致，方法体不同

@override 重写的意思

如何重写？

ALT + INSERT

为什么需要重写？

父类的功能：子类不一定需要，或不一定满足

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Java 如何计算导航路程 java怎么求导

下一篇：python爬取的短视频播放不了是为什么 python爬取小视频

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

java 返回list对象中某个值 java返回对象数组

java 返回list对象中某个值 java返回对象数组

文章目录

Java基础04

数组复习

Java内存

二维数组

Arrays类

面向对象

方法的定义

方法的调用

创建与初始化对象

构造器详解

封装

继承

51CTO博客