day06对象和类

对象9-1

认识

核心OOP-Object-Oriented Programming：物以类聚，善于分类

抽象

三大特性：

1. 封装
2. 继承（final修饰不可继承-工具类）
3. 多态

回顾method

修饰符 返回值 方法名(){}
//涉及方法的重载 见day05
方法名 见名知意
public static void test(double... x){}//参数 可变传参的写法

public void readFile(String fileName) throws IOException {}//异常抛出
完整的方法应该要包括处理异常问题

方法的调用
    静态方法
    非静态方法
    形参与实参
    值传和引用传参
    this关键字（return this.name=name等等）

遵循一个原则：static方法和类以及加载，是类级别的，因此当方法相互调用时就知道问题所在。如：

public static void a(){
    b();//不可以，因为加载时没有b方法
}//static方法
public void b(){}//普通方法

java是值传的

package com.example.demo.oop;
//class Student
public class Student {
    public static void main(String[] args) {

    }
    public void say(){
        System.out.println("hello from class Student with not static");
    }
    public static void say2(){
        System.out.println("hello from class Student with static");
    }
}

package com.example.demo.oop;
/*OOP9-1 Object-Oriented Programming
以类的方式组织代码，以对象的形式封装代码。

* */
public class Demo01 {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.say();//非static需要实例化才能调用方法
        Student.say2();

        //值传递
        int a=1;
        change(a);//输出10
        System.out.println("outside :"+a);//输出1 值传递 副本 创建即消失

        //引用传递：对象
        Person person=new Person();
        System.out.println(person.name);
        change(new Person());//新对象  不影响原对象值
        //change(person);指向地址
        System.out.println("outside :"+person.name);
    }
    public static void change(int a){
        a=10;
        System.out.println("in change:"+a);
    }
    public static void change(Person person){
        person.name="bill";
        System.out.println("in change:"+person.name);
    }

}
class Person{
    String name;
}

类和对象

以类的方式来组织代码，以对象的形式来封装数据

类是对某一类事物的抽象，对象是类的实例，类是对象的模块

🌰 你我是在人这个抽象概念上的具体实例

没有对象？？？ new一个就好了，😸

一个类应该只有方法和属性

new会产生类的实例化-返回对象，new会分配空间，同时进行默认初始化和对类的构造器（构造方法）的调用。

构造器：

1. 必须和类名相同
2. 必须没有返回值，也不能为void。

new时就是在调用默认的无参构造方法进行初始化，当定义显示构造函数时，默认构造函数必须显示，不然会报错。用来初始化值

package com.example.demo.oop;

public class Person2 {
    String name;
    //无参构造
    public Person2(){
        this.name="xxx";//构造方法会初始化对象，因为默认为空，显示调用后new初始化的就是我们自定义的初始值

    }

    //有参构造
    public Person2(String name){
        this.name=name;
    }
}

package com.example.demo.oop;

public class Demo02 {
    public static void main(String[] args) {
        Person2 p2 = new Person2("shell");
        System.out.println(p2.name);//输出shell而不是xxx
    }
}

原因：默认无参在有参构造失效，但是可能仍然需要调用无参构造，所以需要显示调用无参构造

alt+ins可以快捷生成构造器

重载与重写

一个类里有不同参数的同名方法为重载，子类继承父类写了一个同名方法是重写

简单的对象内存分析

package com.example.demo.oop;

public class Pet {
    public String name;
    public int age;

    public void eat(){
        System.out.println(this.name+" is eating");
    }
}

package com.example.demo.oop;

public class Demo03 {
    public static void main(String[] args) {
        Pet dag = new Pet();
        dag.name="xiaobai";
        dag.age=10;
        dag.eat();

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

        Pet cat = new Pet();
        cat.name="xiaohua";
        cat.age=10;
        cat.eat();
        System.out.println(cat.name);
        System.out.println(cat.age);
    }
}

当执行

Pet cat = new Pet()

先在堆中创建Pet对象（分配内存，初始化name为null、age为0）。

再在栈中创建cat引用，让cat“指向” 堆中这个新创建的Pet对象。

栈存局部变量信息引用

堆存对象和属性等

☕