第九天、面向对象

一、匿名对象

1. 没有对象名的对象
2. 使用场景
   • 使用匿名对象调用方法，该方法只需要调用一次
   • 使用匿名对象作为返回值
   • 使用匿名对象作为方法的参数

package com.la;
public class Student {
    private String name;
    private String address;
    private int age;
    public Student(){

    }
    public Student(String name,String address,int age){
        this.address=address;
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName(){
        return this.name;
    }
    public void sleep(){
        System.out.println(this.name+"正在睡觉");
    }
    public Student getStudent(){
        return new Student();
    }
    public void play(Student s){
        System.out.println(s.name);
    }
}
class Test{
    public static void main(String[] args) {
        Student student = new Student("李四", "广州", 21);
        new Student("张三","北京",10).sleep();
        System.out.println(student.getStudent());
        student.play(new Student("王五","上海",12));
    }
}

二、成员变量与局部变量的区别

1. 位置不同：成员变量定义在类中并在方法之外，局部变量定义在方法之中
2. 生命周期不同：成员变量随着对象的创建而创建，对象的销毁而销毁；局部变量随着方法的加载而加载，方法的销毁而销毁
3. 存储位置不同：成员变量是存储在堆中，局部变量是在栈中存储
4. 是否有默认值：局部变量无默认值，必须先赋值在使用；成员变量有默认值

三、封装

1. 隐藏属性内部的细节，提供对外访问的方法，提高了代码的安全性、可扩展性、可维护性

四、构造方法

1. 无参构造：实例对象；有参构造：实例化对象并给成员变量赋值
2. 构造方法不能自身来调用，可由jvm来进行调用
3. 与set方法的是：set方法可以多次给成员变量赋值，构造方法只能赋值一次

五、Javabean

1. 表示一个类的规范，在定义类是需遵守的规范

package com.la;
import java.util.Scanner;
public class Penguin {
    private String name;
    private  int age;

    public Penguin() {
    }

    public Penguin(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Penguin{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Test01{
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);
       Penguin[] penguins=new Penguin[2];
        for (int i = 1; i <=penguins.length; i++) {
            System.out.println("请输入第"+i+"只企鹅的名字：");
            String next = r.next();
            System.out.println("请输入第"+i+"只企鹅的年龄：");
            int nextInt = r.nextInt();
           penguins[i-1]=new Penguin(next,nextInt);

        }
        for (Penguin penguin : penguins) {
            System.out.println(penguin);
        }
    }
}

六、静态

1. 关键字：static；修饰类、方法、变量；

6.1 静态变量

1. 没有静态之前：多个对象相同的属性值，都需要在堆内存中开辟空间进行存储，内存浪费，需要统一修改比较麻烦；
2. 有静态之后：使用静态，只需要在方法区中的静态区间开辟一块区间。实现所有对象共享，节省空间，修改比较方便；
3. 特点：静态变量优先于对象先存在，静态变量是存储在方法区中，通过类名.静态变量名/对象.静态变量名进行赋值
4. 静态变量又称类变量，随着类的加载而加载，静态资源是最不容易被gc回收的

6.2 静态方法

1. 静态方法不能访问非静态的变量：静态资源优先于对象存在
2. 静态方法不能访问非静态方法：同上
3. 静态方法不能访问this关键字：同上
4. 总结：静态方法中是不能访问非静态资源的

6.3 静态变量与成员变量的区别

1. 静态变量又称类变量，成员变量又称对象变量
2. 静态变量在方法区中的静态区，成员变量在堆中
3. 成员变量是随着对象创建而创建，随着对象的回收而回收；静态变量随着类的加载而创建
4. 成员变量通过对象调用，静态变量通过类来调用

七、练习

7.1 MyTime

package com.la;
public class MyTime {
    private int hour;
    private int minute;
    private int second;

    public MyTime() {
    }
    public MyTime(int hour, int minute, int second) {
        this.hour = hour;
        this.minute = minute;
        this.second = second;
    }

    public int getHour() {
        return hour;
    }
    public void setHour(int hour) {
        this.hour = hour;
    }

    public int getMinute() {
        return minute;
    }
    public void setMinute(int minute) {
        this.minute = minute;
    }
    public int getSecond() {
        return second;
    }
    public void setSecond(int second) {
        this.second = second;
    }
    public String dispaly() {
       /* return "MyTime{" +
                "hour=" + hour +
                ", minute=" + minute +
                ", second=" + second +
                "}";*/
        return hour+":"+minute+":"+second;
    }
    public void addSecond(int sec){
        this.second=this.second+sec;
        if (this.second>=60){
            this.second=0;
            this.minute=this.minute+1;
        }
    }
    public void addMinute(int min){
        minute+=min;
        if (this.minute>=60){
            this.minute=0;
            this.hour=this.hour+1;
        }
    }
    public void addHour(int hou){
        hour+=hou;
        if (hour>24){
            System.out.println("请重试");
        }
    }

}
class Test02{
    public static void main(String[] args) {
        MyTime myTime = new MyTime(22, 39, 15);
        myTime.addHour(1);
        myTime.addMinute(2);
        myTime.addSecond(15);
        System.out.println(myTime.dispaly());
    }
}

7.2 /7.3/7.4/7.5/7.6

略