java学习——Day06：面向对象（中）

5.创建对象内存分析

//创建一个宠物类
package com.study.opp;

public class Pet {
    String name;
    int age;
    //无参构造

    public void shout(){
        System.out.println("叫了一声！");
    }
}

//创建一个application类
package com.study.opp;

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

        Pet dog = new Pet();
        dog.name="旺财";
        dog.age=3;
        dog.shout();

        System.out.println(dog.age);
        System.out.println(dog.name);
    }
}
//上面两个运行之前都存在内存里的方法区中
//运行过程
//1.首先运行到applicatin里的main()方法，main()进入栈中
//2.main()方法在new pet类时，Pet类生成了一个dog引用变量名（类似与地址）加载到了栈区，真正的dog对象存放在堆区中
//对于静态方法区来说，static：和类一起加载，可以直接创建对象到堆区，不需要new

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OEJE87rR-1620741848568)(C:\Users\zhengxu\Pictures\创建对象内存分析.png)]

6.简单小结类与对象

​ 1.类与对象

​ 类是一个模板：抽象，对象是一个实例

​ 2.方法

​ 定义、调用。

​ 3.对象的引用

​ 引用类型：基本类型（8）

​ 对象是通过引用来操作的。（由栈指向堆的地址）

​ 4.属性：字段Field 成员变量

​ 默认初始化：

​ 数字：0 0.0

​ char：u0000

​ boolea：false

​ 引用：null

​ 修饰符 属性类型 属性名=属性值！

​ 5.对象的创建和使用

• 必须使用new关键字创造对象，构造器 Person zhengxu= new Preson;

• 对象的属性 zhengxu.name

• 对象的方法 zhengxu.sleep

6.类：

​ 静态的属性 属性

​ 动态的属性 方法

7.封装

程序设计要追求“高内聚，低耦合，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）：通常，应进制直接访问一个对象中数据的实际表示，而应该通过接口来访问，这称为信息隐藏。

记住这句话就够了：属性私有，get/set

//学生类
package com.study.opp.demo03;

public class Student {

    //属性私有
    private String name;  //名字
    private int id;  //名字
    private char sex;    //性别
    private int age;   //年龄

    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法

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

    //alt+insert可以自动生成get和set！！！！！！！！！！！！！！！！！！1

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>0&&age<120){
            this.age = age;
        }else {  //不合法就输出3岁
            this.age=3;
        }

    }
}

//=================================
package com.study.opp.demo03;

/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加了
*/
public class application {
    public static void main(String[] args) {
        Student s1=new Student();
        //s1.name;//报红，无法直接调用

        //通过set和get来设置和获取数据
        s1.setName("郑旭");

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

        s1.setAge(999);//不合法的，可以用set来规避
        System.out.println(s1.getAge());
    }
}

8.继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是”扩展“。子类是父类的扩展。

JAVA中只有单继承，没有多继承。（c++就有）

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，用关键字extends来表示。子类和父类之间，从意义上讲应该具有"is a"的关系。

object类

super:访问父类的属性和方法 this：访问本类的属性和方法

//=========新建一个Person类=========//
package com.study.opp.demo04;

//在java中都默认直接或间接继承object这个类！！！！
//Person 人:基类 父类
public class Person {
    //public
    //protected
    //default
    //private
    private int money; //子类不能用super使用父类私有的属性和方法
    public int getMoney() {
        return money;
    }
    
    protected String name="小臭"；
        
    public void setMoney(int money) {
        this.money = money;
    }
    
    public void say(){
        System.out.println("说了一句话");
    }
    
    //父类无参构造
    public Person(){
        System.out.println("Person无参构造执行了")；
    }
 
}
//=========新建一个Student类=========//
package com.study.opp.demo04;

//学生 is 人：派生类  子类
//继承了父类，就会拥有父类的所有方法
public class Student extends Person{
	
    private String name="小胖"；
    
    public void test(String name){
        System.out.println(name); //传递的name
        System.out.println(this.name); //本类的name："小胖"
        System.out.println(super.name);   //父类的name："小臭"
    }
    
    //子类无参构造
    public void Student(){
        //隐藏代码：调用了父类的无参构造器：super();
        super();//调用父类的构造器必须写在第一行，不写也行，默认存在
    	System.out.println("Student无参构造执行了");
    }
    
}
//=========新建一个Teacher类=========//
package com.study.opp.demo04;

//老师 is 人：派生类 子类
public class Teacher extends Person {

}

//=============具体操作============//
package com.study.opp.demo04;

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

        Student student = new Student();//输出：Person无参构造执行了
        								//     Student无参构造执行了
        
        
        student.say();//学生类里面没有方法，但因为继承了父类，所以拥有了父类的所有方法
        
        student.test("嘀嘀嘀");      
    }
}

9.super详解

super注意点：

​ 1.super调用父类的构造方法，必须在构造方法的第一行

​ 2.super必须只能出现在子类的方法或者构造中！

​ 3.super和this不能同时调用构造方法！

VS this：

​ 代表的对象不同：

​ this：本身调用者这个对象

​ super：代表父类对象的应用

​ 前提：

​ this：没有继承也可以使用

​ super：只有在继承条件下才能使用

​ 构造方法：

​ this():本类的构造

​ super()：父类的构造！

10.方法重写

重写：需要有继承关系，子类重写父类的方法！

​ 1.方法名必须相同

​ 2.参数列表必须相同

​ 3.修饰符：范围可扩大： private<protected<default<private

​ 4.抛出的异常：范围被缩小，但不能扩大：ClassNotFoundException—>Exception(大)

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

快捷键：alt+insert:override

为什么需要重写？

​ 1.父类的功能，子类不一定需要，或者不一定满足

父类和子类都是静态方法(static)的重写：方法的调用只和左边定义的数据类型有关

//父类
package com.study.opp.demo05;

//重写都是方法的重写,和属性无关
public class A {

    public static void test(){
        System.out.println("A=>test()");
    }
}

//子类
package com.study.opp.demo05;

public class B extends A{

    public static void test(){
        System.out.println("B=>test()");
    }
}

//应用
package com.study.opp.demo05;

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

        //方法的调用只和左边定义的数据类型有关！！！！！！
        B b = new B();
        b.test();  //B=>test()

        //父类的引用指向了子类
        A a=new B();
        a.test();  //A=>test()
    }
}

父类和子类都是非静态方法(无static)的重写：子类能重写父类的方法，和右边定义的数据类型有关

//父类
package com.study.opp.demo05;

//重写都是方法的重写,和属性无关
public class A {

    public static void test(){
        System.out.println("A=>test()");
    }
}

//子类
package com.study.opp.demo05;

public class B extends A{

    @Override
    //重写 快捷键alt+insert
    public void test() {
        System.out.println("B=>TEST()");
    }
}

//应用
package com.study.opp.demo05;

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

        B b = new B();
        b.test();  //B=>test()

        //父类的引用指向了子类
        A a=new B();  //子类重写了父类的方法
        a.test();  //B=>test()
    }
}