JavaSE学习笔记（四）——面向对象（OOP）

最新推荐文章于 2022-05-26 11:45:00 发布

小林小林如履如临

最新推荐文章于 2022-05-26 11:45:00 发布

阅读量666

点赞数 1

分类专栏： JavaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/logan_520/article/details/121697967

版权

JavaSE 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.初识面向对象

面向过程与面向对象的关系——对于描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的的思维来分析整个系统。但是，具体到微观操作，仍然需要使用面向过程的思路去实现。

面向对象编程的本质：以类的方式组织代码，以对象的形式封装数据。

面向对象三大特征：封装、继承和多态

2.对象的创建分析

对象创建

类是抽象的、是对象的模板；而对象则是一个具体的事物。类实例化后会返回一个自己的对象，即对象就是类的具体实例。

下面这个例子中，xiaoming这个对象就是Student学生类的具体实例！

//学生类
public class Student {

    //属性：字段
    String name;
    int age;

    //方法
    public  void  study()
    {
        System.out.println(this.name + "在学习");
    }
}

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

        xiaoming.name="小明";
        xiaoming.age=18;

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

        xiaoming.study();
    }
}

构造器（构造方法）

特点：定义时和类名相同且没有返回值。

作用：1.使用new关键字，本质是在调用构造方法

2.初始化对象的值

注意点：一旦定义了有参构造，那么无参构造就必须显示定义

public class Person {
    //一个类即使什么都不写，也会存在一个默认的构造方法
    String name;


    //1.使用new关键字，本质是在调用构造器
    //2.初始化值

    //无参构造,默认存在
    public Person(){}

    //有参构造：一旦定义了有参构造，那么无参构造就必须显示定义
    public Person(String name)
    {
        this.name=name;
    }
}

public class Demo05 {
    public static void main(String[] args) {
        Person person =new Person();
        person.name="xiaoming";

        Person xiaolin = new Person("xiaolin");

        System.out.println(person.name);
        System.out.println(xiaolin.name);
    }
}

内存分析

首先，程序加载Demo06这个类，将这个类存入方法区里的一个内存空间，并将类里的main()方法也存入其中、常量（旺财和大咪）存入常量池中，再是执行main()方法，先是new了Pet类的dog对象，这就要在方法区开辟Pet类的空间了，而dog这个引用变量名会在栈中存放，引用地址指向堆中对象的内存空间，然后就是从Demo06类中取出数据为对象的属性赋值，而方法是从Pet类中获得的；后面new的cat对象也是同样的道理~

还有一点，构造器是在类实例化之后才存在的，而static是和类一起加载的，所以在类的外部可以通过类名直接去调用static修饰的属性和方法，在类的内部也是可以直接通过方法名或属性名来调用的。

public class Pet {
    String name;
    int age;

    //无参构造
    public  void shout()
    {
        System.out.println("叫了一声");
    }
}

public class Demo06 {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name="旺财";
        dog.age=3;

        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.shout();

        Pet cat = new Pet();
        cat.name="大咪";
        cat.age=2;

        System.out.println(cat.name);
        System.out.println(cat.age);
        cat.shout();

    }
}

3.面向对象三大特征

—封装（数据的隐藏）

该漏的漏，该藏的藏，追求“高内聚，低耦合”——高内聚：类的内部数据由自己操作完成，不允许外部的干涉；低耦合：仅暴露少量的方法给外部使用。

封装的方法：属性私有，get/set，就是属性设置为私有，用private修饰，在外部通过get和set方法来获取和设置类的属性。

封装的意义：1.提高程序的安全性，保护数据

2.隐藏代码实现的细节

3.统一接口，方法都用get/set

4.提高系统的可维护性

—继承

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

有继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类用extends来表示。子类和父类之间，从意义上讲应该具有“is a”的关系，就好比父类为Person，子类为Student，那么就有Student is a Person 。一旦子类继承了父类，那么子类就会拥有父类的所有方法，但属性一般是不会继承的，因为封装的思想，所以属性一般都是由private修饰的，不会被子类所拥有了。

在Java中，类只有单继承，没有多继承，并且所有的类，都默认直接或间接继承obje类

使用super的注意事项：

子类调用父类的构造方法，super()必须出现在子类构造方法的第一行

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

在子类的构造方法中，不能同时出现super()和this(),二者只能唯一

this 与 super 的区别

①代表对象不同：this指自身调用者的对象，super指父类的对象

②前提条件不同：this在类没有继承的情况下也可以使用，而super只有在继承的条件下才可以使用

③代表的构造方法不同：this()指本类的构造，super()指父类的构造

方法重写

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

tatic, final, private 关键词修饰的方法不能重写

注意点：1.方法名必须相同

2.方法的参数列表必须相同

3.重写时修饰符的范围可以扩大但不能缩小

4.抛出的异常范围可以缩小但不能扩大

—多态

概念：同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的的实际类型是确定的，但可以指向的对象的引用类型有很多，如父类，有关系的类。例子：Student类继承了Person类,那么，Student a = new Student(); Person b = new Student(); object c = new Student()都是可以的。

多态的注意事项：

多态是方法的多态，属性没有多态

子类和父类要有联系

存在的条件：要有继承关系，子类需要重写父类方法，父类的引用指向子类对象

引用类型转换

instanceof 关键字，可以判断一个对象的类型，X instanceof Y 编译是否成功要看 X指向的实际类型是否为Y的子类型，即X 和 Y 是否存在联系。

public class Demo08 {
    //Object > String
    //Object > Person > Teacher
    //Object > Person > Student
    public static void main(String[] args) {
        //X instanceof Y  X指向的实际类型是否为Y的子类型 编译是否成功
        Object object = new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person  instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person  instanceof Teacher);//false
        //System.out.println(person  instanceof String);//编译报错

        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(student instanceof String);//编译报错
     }
}

引用类型转换，是父类和子类之间的转换，遵循低转高不用强转，而高转低则需要进行强制转换的原则，但当子类转为父类时，可能会丢失子类本来的一些方法。