day09 面向对象编程

最新推荐文章于 2024-09-15 19:46:31 发布

m0_61260513

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量129

点赞数

分类专栏： JavaSE笔记文章标签： java intellij-idea

本文链接：https://blog.csdn.net/m0_61260513/article/details/120024857

版权

JavaSE笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1、对象关联

对象和属性是隶属关系，即对象拥有属性，属性被对象拥有

对象传递和对象关联的区别是什么？

对象传递：对象和方法之间关系松散实参-形参

对象关联：关系紧密，一个对象拥有另外一个类的对象，目的是在本对象中方便使用另一个对象

如何关联呢?

在一个类中把另一个类的对象作为本类的属性

一旦添加了属性，就要进行以下操作：

1、调整构造器

2、提供get。set方法

3、改造say()方法

对象关联的真实动作，是通过构造器完成

package com.atguigu.javase.javabean;

public class Person {

    private String name;
    private int height;
    private int weight;
    private Phone myphone;//添加属性

    public Person(){}

    //调整构造器
    public Person(String name,int height,int weight,Phone phone){
        this.name = name;
        this.height = height;
        this.weight = weight;
        this.myphone = phone;
    }

    public void setName(String name){
        this.name  = name;
    }
    public String getName(){
        return name;
    }
    public  void setHeight(int height){
        this.height = height;
    }
    public int getHeight(){
        return height;
    }
    public void setWeight(int weight){
        this.weight = weight;
    }
    public int getWeight(){
        return weight;
    }
   //添加set  get方法
    public void setPhone(Phone phone){
        this.myphone = phone;
    }
    public Phone getPhone(){
        return myphone;
    }

    //调整say()方法
    public String say(){
        return "姓名："+name+"  身高："+height+" 体重："+weight+" 手机参数:"+myphone.say();
    }

    public void wangzhe(){
        System.out.println(name+"在使用手机["+myphone.say()+"]玩王者荣耀");
    }

    public void taobao(){
        System.out.println(name+"使用手机["+myphone.say()+"]逛淘宝");
    }

}

2、数组与for循环

完美数组：所有的数组元素都是有效对象没有空洞

结构良好数组：前面都是连续的有效对象，后面是连续的空洞

扩容数组遍历是需要注意空洞

经典for循环和增强性for循环的联系和区别

联系：两者是等价的

区别：

1）增强性for循环也称为foreach循环，其优点是只读、安全、简单

格式：

for(数组元素类型临时变量：数组名){

访问临时变量

}

它隐藏了数组下标

        for(Student tmp:stuArr){
        System.out.println(tmp.say());
        }

2）找最大值要用下标法，必须用经典for循环；而增强for循环用于遍历

 //创建一个小容量的数组对象
        Student[] newArr = new Student[stuArr.length-6];
        //将老数组对象里的前几个存入新数组对象中
        for (int i = 0; i < newArr.length; i++) {//i 右边的值，谁短就写谁 因为下面刷值操作是大的往小的里放才不会出现空指针异常现象
            newArr[i] = stuArr[i];
        }
        //让老数组也指向新数组的内存地址
        stuArr = newArr;
        //此时老数组也已经指向了新数组，输出的一定是老数组中存的对象
        for (Student s : stuArr) {
            System.out.println(s.say());
        }

3、数组算法

反转：首位交换

 for (int i = 0; i < stuArr.length / 2; i++) {
            Student tmp = stuArr[i];
            stuArr[i] = stuArr[stuArr.length-i-1];
            stuArr[stuArr.length -i - 1] = tmp;
        }
        for (Student s : stuArr) {
            System.out.println(s.say());
        }

数组缩减

1)新建一个容量小的数组

2)依此复制元素到新数组，复制的个数为短的为准

3)老引用指向新数组对象，老数组对象变垃圾

分析图

代码分析

//将学生对象数组缩减为1/3
        Student[] newArr = new Student[stuArr.length/3];//创建新的容量比较小的数组对象
        for (int i = 0; i < newArr.length; i++) {
            newArr[i] = stuArr[i];//复制数组元素到新的数组中，个数以新的为主
        }
        stuArr = newArr;//老引用指向新的数组对象，之前的老数组对象变成垃圾

        for(Student tmp:stuArr){
            System.out.println(tmp.say());//输出的是新数组中的对象元素 因为stuArr的地址已经发生改变
        }
    }

数组扩容

本质上和数组扩容一样

//扩容的原理和缩减的原理是一样的
        //创建一个容量足够大的数组对象
        Student[] newArr = new Student[(int)(stuArr.length*1.5)];//特别要注意类型转换
        //将老数组中的对象存入新数组之中，i右边的范围要是两者中短的哪一个
        for (int i = 0; i < stuArr.length; i++) {
            newArr[i] = stuArr[i];
        }
        //让老数组也指向新数组得地址
        stuArr = newArr;

        for (Student s : stuArr) {
            //这里会出现一个空洞问题 那么我们就要进行判断 如果数组元素为null 不.say()  否则.say()
            if(s != null){
                System.out.println(s.say());
            }else{
                System.out.println(s);
            }
        }

取子数组

1)创建容量足够大的新数组，防止全是有效元素
2)声明计数器，初始值为0，共功能有2：a.本质功能 b.新元素插入到新数组时的下标
3)遍历老数组
4)查找符合条件的数据
5把符合条件的元素插入到新数组中，下标由计数器指示
6)调整计数器
7)把新数组缩减为计数器个数的数组

分析图

代码实现

 //创建一个和老数组一样大的新数组，用来存放取出来的对象
        Student[] newArr = new Student[stuArr.length];
        //设置一个计数器  其作用有二  1.用来记录满足条件的数的个数 2.用来指示下一个数的下标
        int count = 0;
        //遍历老数组 找出符合条件的对象
        for (int i = 0; i < stuArr.length; i++) {
            if(stuArr[i].getGrade() == 3){
                //如果符合条件，就要将老数组中的对象传给新数组
                newArr[count] = stuArr[i];//把这个对象放在新数组的count位置上 使其成为一个结构良好的数组（有来连续的有效值）
                count++;
            }
        }
        //再创建一个最终数组，用来存放新数组中的对象，使之成为一个完美数组（没有空值）
        Student[] finalArr = new Student[count];//count位置前的数都是新数组中的有效位置
        for (int i = 0; i < count; i++) {
            finalArr[i] = newArr[i];
        }
        //并不用提防空洞现象，因为如果不满足条件的话，数组中就什么也没有 就好像一个没放任何东西的空抽屉
        for (Student f : finalArr) {
            System.out.println(f.say());
        }

删除一个元素

1）把要删除的下标置为空洞

2）把右面搜友有效对象整体左移

3）把之前最的后的元素处置空

4）调整计数器

分析图

代码实现

//将要删除的元素下标置为空
        int index = 4;  //删除下标是四的元素
        //设置count用来标记空洞的前一个位置，也是本省数组的长度 这样做是因为我们只处理有效元素 如果后面有很多null 就可以不用做处理
        int count = 10;
        //对从index开始到count-1结束的元素进行移动
        stuArr[index] = null;
        for (int i = index; i < count-1; i++) {//这里之所以要设置成count-1 是因为最后一个数字移动到前面，那里会变成空洞
            stuArr[i] = stuArr[i+1];
        }
        //对count进行操作让它移动到重复的哪一个元素的位置 并设置为空洞
        stuArr[count-1] = null;
        //这里要count--是因为删除了一个元素 所以长度就减一
        count--;

        for (int i = 0; i < count; i++) {
            System.out.println(stuArr[i].say());
        }

冒泡排序

//冒泡排序
for (int i = 0; i < stuArr.length; i++) {
    for (int j = 0; j < stuArr.length-1-i; j++) {
        if(stuArr[j].getScore() > stuArr[j+1].getScore()){
            Student t =  stuArr[j];
            stuArr[j] = stuArr[j+1];
            stuArr[j+1] = t;
        }
    }
}