关于面向对象

最新推荐文章于 2024-08-12 16:47:32 发布

m0_55505843

最新推荐文章于 2024-08-12 16:47:32 发布

阅读量50

点赞数

文章标签： java 开发语言 Powered by 金山文档

本文链接：https://blog.csdn.net/m0_55505843/article/details/129170589

版权

Day08

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体的描述、定义，但是不能的代表某个具体的事物‘

动物、植物、人......

Preson类、Pet类、Car类等

对象是抽象概念的具体实例

张三就是人的一个具体实例，来福就是狗的一个具体实例。

能够体现出特点，展现出功能的具体实例，而不是抽象的概念。

创建与初始化对象

使用new关键字创建对象

使用new关键字创建的时候，出了分配内存空间外，还会给创建好的对象进行默认的初始化及对类中构造器的调用。

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有两个特点：

必须和类的名字相同

必须没有返回值，也不能写void

构造器必须掌握

package oop.FaceObject;

public class Function {
    //一个项目应该只有一个main方法
    public static void main(String[] args) {
        //实例化一个对象
        Person xiaoming = new Person("wu");
        System.out.println(xiaoming.name);

    }
}

package oop.FaceObject;

public class Person {
    //一个类中即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name ;

    //无参构造
    //使用new关键字 本质是在调用构造器
    //用来初始化值
    public Person(){
        this.name="wumou";
    }

    //有参构造：有了有参构造，无参构造就一定要显示定义
    public Person(String name){
        this.name = name;//this.是指向当前类中的对象
    }
    //快捷键alt + insert 生成构造器
}

封装

该露的露该藏的藏

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

封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

属性私有：get/set

package oop;

import oop.Encapsulation.Student;

public class Function {
    public static void main(String[] args) {
        Student xiaomin = new Student();
        xiaomin.setName("wjh");
        xiaomin.setAge(150);//不合法数值
        System.out.println(xiaomin.getAge());
        System.out.println(xiaomin.getName());
    }
}

package oop.Encapsulation;
//类

/*
    1.提高了代码的安全性，保护数据
    2.提高代码的可维护性
    3.隐藏代码的实现细节
    4.统一接口
 */
public class Student {
    //封装关键字   private：私有
    //属性私有
    private String name;
    private int age;

    //提供一些可以操作该属性的方法！
    //提供一些public 的 get set 方法

    //get 获得这个数据
    public  String getName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name){
        this.name=name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //可以规避不合法数值
        if(age<=120 || age>0){
            this.age = age;
        }else {
            age = 3;
        }

    }
}

继承

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

extands的意思是"扩展"。子类是父类的扩展。

JAVA中类只有单继承，没有多继承！

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

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extands来表示。

子类和父类之间，从意义上来讲应该具有“is a”的关系。

package oop.demo01;
//父类   基类
//子类继承了父类  就会拥有父类全部的方法
//java中所有类都默认直接或间接继承Object类
public class Person {

    public int money = 1_0000_0000;

    public void say(){

        System.out.println("说了一句话");
        
    }

}

package oop.demo01;
//子类  派生类
public class Student extends Person{

}

Object类：所有类都默认直接或间接继承Object类

super

package oop.demo01;
//父类
public class Person {

    public  Person(){
        System.out.println("Person");
    }
    public String name = "吴某";

}

package oop.demo01;
//子类
public class Student extends Person{

    public  Student() {
        //隐藏代码  调用了父类的无参构造

        super();//调用父类的无参构造 必须在子类构造方法的第一行  无法同时使用this
        System.out.println("Student");
    }
    private String name = "wu";

    public void test(String name){
        System.out.println(name);//输出结果为Functin类中赋予name属性
        System.out.println(this.name);//输出结果为当前方法中name的属性
        System.out.println(super.name);//输出结果为父类中name的属性
    }


}

package oop;
//运行
import oop.demo01.Student;

public class Function {
    public static void main(String[] args) {
        Student xiaoming = new Student();

        xiaoming.test("wumou");
    }

}

注意点：

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

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

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

VS this

代表的对象不同：

this：调用本身的这个对象

super：调用父类的对象

前提：

this没有继承也可以使用

super只能在继承条件才可以使用

构造方法

this () ; 本类的构造

super () ; 父类的构造；

方法重写

package oop.demo02;
//重写是方法重写 和属性无关
public class A {
    public  void test(){
        System.out.println("A");
    }
}

package oop.demo02;
//继承
public class B extends A{
    //Override 重写
    @Override  //注解  有功能的注释
    public void test() {
        System.out.println("B");
    }
}

package oop;

import oop.demo02.A;
import oop.demo02.B;

public class Function {
    //静态方法  方法的调用只和左边定义的数据类型有关
    //非静态方法才能重写

    public static void main(String[] args) {
        A a = new B();//子类重写了父类的方法
        a.test();
        B b = new B();
        b.test();
    }
}

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

1. 方法名必须相同

1. 参数列表列表必须相同

1. 修饰符：范围可以扩大但是不能缩小； public>Protected>Default>private

1. 抛出的异常：范围可以缩小但是不能扩大； ClassNotFoundException -->Exception(大)

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

为什么需要重写：

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

Alt + Insert ; override;