今日内容

零、复习昨日
一、一日一题(数组,OOP)
二、面向对象练习（方法参数返回值）
三、局部变量&成员变量
四、this关键字
五、构造方法
六、重载
七、封装

小破站同步上课视频:
https://space.bilibili.com/402601570/channel/collectiondetail?sid=1091094

零、复习昨日

见晨考

一、一日一题

2 写一个方法用于合并两个int类型的数组合并法则如下（合并去重排序）
{1,2,5,8,9}{1,3,0}---->{0,1,2,3,5,8,9}

package com.qf.homework;

import java.util.Arrays;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class Homework {
    public static void main(String[] args) {
        int[] arr1 = {1,2,5,8,9};
        int[] arr2 = {1,3,0,8};
        plus(arr1,arr2);
    }

    //    {1,2,5,8,9}{1,3,0}---->{0,1,2,3,5,8,9}
    // 先合并再排序后去重
    public static void plus(int[] arr1,int[] arr2) {

        // 合并
        int[] arr3 = new int[arr1.length + arr2.length];

        System.arraycopy(arr1,0,arr3,0,arr1.length);
        System.arraycopy(arr2,0,arr3,arr1.length,arr2.length);
        System.out.println(Arrays.toString(arr3) );
        // 去重
        // 创建新数组,存放不重复的元素
        int[] arr4 = new int[arr3.length];

        Arrays.sort(arr3);
        arr4[0] = arr3[0];

        int index = 1;
        // 取原数组元素
        for (int i = 1; i < arr3.length; i++) {
            boolean flag = false;// 不重复
            // 取去重后数组的元素
            for (int j = 0; j < arr4.length; j++) {
               if (arr3[i] == arr4[j]) {
                   flag = true;
               }
            }

            if (!flag) {
                arr4[index] = arr3[i];
                index++;
            }
        }
        int[] arr5 = new int[index];
        System.arraycopy(arr4,0,arr5,0,index);
        System.out.println(Arrays.toString(arr5));
    }
}

3 面向对象

PDF5T10 根据要求创建类和对象

public class Worker {

    String name; // 姓名
    int age;//年龄
    double salary;// 薪水


    public void work(){
        System.out.println("工人工作" );
    }


    public void work(int hour) {
        System.out.println("工人工作时长:"+hour );
    }

}
// 同一个java文件中只能有一个公共的类
// 且公共的类的名字要和外面文件名一样
class TestWorker{

    public static void main(String[] args) {
        Worker worker = new Worker( );

        worker.age = 19;
        worker.name = "zzz";

        worker.work();
        worker.work( 10 );
    }

}

T11

public class Address {

    String address;
    String zipCode;


}

T12

package com.qf.homework;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc  引用类型: 数组,类,接口
 */
public class Worker {

    String name; // 姓名
    int age;//年龄
    double salary;// 薪水
    // 地址类属性
    Address addr;
  //数据类型 变量名;

    public void work(){
        System.out.println("工人工作" );
    }


    public void work(int hour) {
        System.out.println("工人工作时长:"+hour );
    }
}
// 同一个java文件中只能有一个公共的类
// 且公共的类的名字要和外面文件名一样
class TestWorker{

    public static void main(String[] args) {
        Worker worker = new Worker( );

        worker.age = 25;
        worker.name = "zhangsan";
        worker.salary = 2500;

        // Address addr = new Address();
        // worker.addr = addr;
        worker.addr = new Address();
        worker.addr.address = "郑州"; // 注意空指针异常问题
        worker.addr.zipCode = "4000";

        System.out.println(worker.age );
        System.out.println(worker.salary );
        System.out.println(worker.name );
        System.out.println(worker.addr.address );
        System.out.println(worker.addr.zipCode );
    }
}

二、面向对象练习

练习方法参数,返回值的使用

public class Phone {

    String brand;
    double price;

    public boolean call(String num) {
        System.out.println(brand + "打电话" + num);
        System.out.println("这个手机价格:" + price);
        return true;
    }

}
class TestPhone {

    public static void main(String[] args) {

        Phone phone = new Phone( );
        phone.brand = "MI";
        phone.price = 1888.0;

        boolean isok = phone.call("120");
        System.out.println("打电话是否成功? " + isok );
    }

}

三、局部变量&成员变量

	局部变量	成员变量
`位置`
`作用域`
`初始值`
内存位置
生命周期

public class Phone {

    /**
     * 成员属性就是成员变量
     * 1 类中方法外
     * 2 类中所有方法都可以使用
     * 3 成员变量会随着创建对象时被赋默认值(即可以不用主动考虑初始值的事)
     * 4 成员变量在内存的堆中
     * 5 在对象创建时出现并初始化,失去引用后,会把垃圾回收机制处理(GC)
     */
    String brand;
    double price;

    /**
     * 局部变量
     * 1 方法参数列表内和方法体内
     * 2 只能在方法内部使用
     * 3 局部变量使用前必须主动赋值
     * 4 局部变量是在栈的栈帧中
     * 5 随着方法进栈而出现,方法执行完出栈而消失
     */
    public boolean call(String num) {
        int a = 1;
        System.out.println(a );
        System.out.println(brand + "打电话" + num);
        System.out.println("这个手机价格:" + price);
        return true;
    }
}

四、this关键字

this就是代表当前对象
当前对象是指,谁调用这个方法,this就代表调用这个方法的对象

因为this代表的是对象,所以它就可以调用对象的属性和方法
this.属性;
this.方法();

package com.qf.oop;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class Car {

    String brand;
    double price;

    public void run() {
        int a = 1;
        String brand = "五菱";
        System.out.println("this:"+this );// 输出的是car的地址,代表car对象
        /**
         * 当成员变量和局部变量重名时
         * 使用时,默认使用方法自己的局部变量(就近原则)
         * 如果必须使用成员变量,就使用this来调用
         * 因为this代表对象,所以可以调用对象属性
         */
        System.out.println(this.brand + "车跑动,跑了"+a+"公里" );
        
        // this调用方法
        this.didi();
    }

    public void didi() {
        System.out.println("车鸣笛" );
    }

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

        Car car = new Car( );
        System.out.println("car:" + car );
        car.brand = "BYD";
        car.price = 150000;

        car.run();
    }
}

使用this的场景总结:
当成员变量和局部变量重名时,用this.属性来代表成员变量.

问

this是什么what,能干什么how,什么时候用when?

五、构造方法

构造方法又叫构造器(constructor),是用来创建对象的.
类名对象名 = new 类名(); 其实这个语法应该这么叫
类名对象名 = new 构造方法();

特点

每个类都默认有一个隐藏的无参构造
没有返回值,也不能写void
方法名必须是类名
只能通过new来调用

特殊的,类中没有一个显式构造方法,那么就会默认提供一个隐式无参构造
一旦显式写出任何一个构造方法,隐式的不再提供.

具体作用(构造方法一旦执行)

在堆中开启空间,分配地址值
属性和方法被初始化
对象创建成功,将地址值赋值给变量(对象名)

有参构造

在创建对象时,调用有参构造方法,方法内部有对属性赋值的过程.所以有参构造创建出的对象的属性是指定值.

public class Student {
    String name;
    int age;

    /**
     * 显示的写出无参构造
     * 构造方法语法特点
     * 1. 没有返回值,也不能写void
     * 2. 方法名必须是类名
     */
    public Student(){
        System.out.println("无参构造" );
    }

    /**
     * 有参构造
     */
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void coding(){
        System.out.println("敲代码" );
    }
}
class TestStudent{
    public static void main(String[] args) {
        // ???? 能不能创建出的对象,内部的属性直接有值
        // 能!!! 有参构造
        Student s2 = new Student("奥利安娜", 20);

        System.out.println(s2.age );
        System.out.println(s2.name);
    }
}

总结有参构造和无参构造区别

相同点: 都能创建出对象
不同点: 无参构造创建出的对象属性值都是默认值;; 有参构造创建出的对象属性值是指定值

即两者都是创建对象,只是不同的效果.看情况选择使用

六、重载

重载overload: 指方法的重载

方法是在同一个类中
方法名相同,参数列表不同
参数列表不同: 个数,类型,顺序不同

好处:

方便调用,根据传入的参数的个数,顺序,类型决定执行哪个方法.不用去特别的设计不同的方法名

public class TestOverload {

    public static void main(String[] args) {

        // println其实就是一系列重载的方法
        // 就是方便使用
        System.out.println( );
        System.out.println(1);
        System.out.println(1.1);
        System.out.println("zzz");
        System.out.println(new Student());
        System.out.println('a');

        m1("");

    }


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

    public static void m1(int a) {
        System.out.println("m1(int a)" );
    }

    public static void m1(String a) {
        System.out.println("m1(String a)" );
    }

    public static void m1(String a,int b) {
        System.out.println("m1(String ,int b)" );
    }

    public static void m1(int b,String a) {
        System.out.println("m1(int b,String a)" );
    }
}

Dog类,两个属性,有参无参构造,创建对象

七、类的封装

类的封装: 将代码封装在一个类中,隐藏一些代码实现的逻辑,对外提供一个公共的访问方式.

类的封装实现步骤:

属性私有
提供对应的set,get方法

setter getter方法,很固定

一定是set+属性首字母大写 setXxx getXxx
set方法有参数无返回值
get方法无参数有返回值

public class People {

    // 私有化,这个属性就只能在当前类中使用
    private int age;
    private String name;

    // 提供set方法供赋值
    public void setAge(int age) {
        if (age <= 120 && age >= 0) {
            this.age = age;
        }else{
            System.out.println("年龄有误" );
        }
    }

    // 提供get方法供取值
    public int getAge() {
       return age;
    }


    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }



    public void eat(){
        System.out.println("人吃饭" );
    }

}


class TestPeople{

    public static void main(String[] args) {
        People people = new People( );
        // people.name = "ikun";
        // people.age = -22;

        people.setAge(22);
        int age = people.getAge( );
        System.out.println(age);

        people.setName("kunkun");
        String name = people.getName( );
        System.out.println(name );
    }
}

练习: 封装上题Dog类

八、总结

局部变量成员变量： 能分清，初始值不同
this：代表当前对象，场景用来区分成员变量和局部变量
构造方法： 用来创建对象，有参和无参构造的区别
重载： 是代码的一种设计方式，可以让方法调用更方便
类的封装：先属性私有后提供一对儿setget方法

九、作业

重复2遍代码
作业.txt
pdf5中的每个题（特别10,11,12）

day11_面向对象

今日内容

零、复习昨日
一、一日一题(数组,OOP)
二、面向对象练习（方法参数返回值）
三、局部变量&成员变量
四、this关键字
五、构造方法
六、重载
七、封装

零、复习昨日

一、一日一题

二、面向对象练习

三、局部变量&成员变量

四、this关键字

五、构造方法

六、重载

重载overload: 指方法的重载

七、类的封装

八、总结

九、作业

相关文章

Spring MVC

JSON学习笔记

C++复习笔记9

Python 数据可视化的 3 大步骤，你知道吗？

上海亚商投顾：沪指震荡上行大消费板块全线走强

nodejs学习笔记1.2

00---C++入门

简单易用的以太网IO控制卡：C#读写测试

A-Ops性能火焰图——适用于云原生的全栈持续性能监测工具

2023最新简历模板免费下载

Multimap运用

MongoDB--》基本常用命令使用

docker基础和使用(一)

知识图谱业务落地技术推荐之图数据库汇总

备考蓝桥杯【快速排序和归并排序】

【王道数据结构】第八章 | 排序

3-track网络预测蛋白质结构和相互作用

机械设备管理软件如何选择？机械设备管理软件哪家好？

IPV4地址的原理和配置

【GD32F427开发板试用】7. 移植LVGL到GD32F427V

day11_面向对象

今日内容

零、 复习昨日 一、一日一题(数组,OOP) 二、面向对象练习（方法参数返回值） 三、局部变量&成员变量 四、this关键字 五、构造方法 六、重载 七、封装

零、 复习昨日

一、一日一题

二、面向对象练习

三、局部变量&成员变量

四、this关键字

五、构造方法

六、重载

重载overload: 指方法的重载

七、类的封装

八、总结

九、作业

相关文章

零、复习昨日
一、一日一题(数组,OOP)
二、面向对象练习（方法参数返回值）
三、局部变量&成员变量
四、this关键字
五、构造方法
六、重载
七、封装

零、复习昨日