Java关于面向对象基础概念

最新推荐文章于 2023-10-01 13:03:19 发布

David--

最新推荐文章于 2023-10-01 13:03:19 发布

阅读量103

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/qq_37328448/article/details/108794489

版权

笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Java入门基础（六）

面向对象

面向过程和面向对象：

面向过程思想

步骤清晰简单，第一步做什么，第二步做什么
面向过程适合处理一些较为简单的问题

面向对象思想

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

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

什么是面向对象

面向对象编程（Object-Oriented Programming，OOP）

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

核心思想：抽象，三大特性

三大特征：

封装：把客观事物封装成抽象的类，并且类可以隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。
继承：子类继承父类的过程，继承者可以拥有父类非私有方法属性。
多态：同一个行为具有多个不同表现形式或形态。

从认识论角度烤炉是先有对象后又类。对象：是具体的事物。类：是抽象的，是对对象的抽象

从代码运行角度考虑就是现有类后有对象。类是对象的模板。

类与对象的关系

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

Person类，Pet类，Car类等，这些类都是用来描述/定义某一个具体的事物应该具备的特点和行为。

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

张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。

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

创建与初始化对象

使用new关键字创建对象

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

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

必须和类的名字相同
必须没有返回类型，也不能写void

构造器必须要掌握

public class Person {

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

    //构造器的作用：
    //1.使用new关键字，本质是在调用构造器，必须要有构造器
    //2.实例化初始值
    public Person(){
        this.name = "David";
    }

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

/*  调用代码：
    public static void main(String[] args) {

        //new 实例化了一个对象
        //调用无参构造方法
        Person person1 = new Person();

        //调用有参数构造方法
        Person person2 = new Person("David");

        System.out.println(person1.name);  //David
        System.out.println(person2.name);  //David
    }

    构造器：
        1.和类名相同
        2.没有返回值
    作用：
        1.new本质在调用构造方法
        2.初始化对象的值
    注意点：
        定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造方法

    快捷键 Alt + insert ，选择第一个生成构造函数，自动创建构造方法
*/

类与对象小结：

类与对象：

类是一个模板：抽象的；对象是一个具体的实例
对应的引用：

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

对象是通过引用来操作的：由栈指向堆
属性：字段（Field）/成员变量

默认初始化：

数字： 0，0.0；

char： u0000；

boolean：false；

引用类型： null

修饰符属性类型属性名 = 属性值！
对象的创建和使用：
- 必须使用new关键字创建对象，必须要有构造器；
- 对象的属性： David.name；
- 对象的方法： David. study()；
类中存在的东西：

静态的属性：属性

动态的行为：方法

封装

该露的露，该藏的藏

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

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

//类， private：私有
public class Student {

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

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

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

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

    public int getId() {
        return id;
    }

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

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //判断输入的年龄是否合法
        if (age>120 || age<0){
            //不合法则设置为3岁
            this.age = 3;
        }else {
            //合法则设置为输入的年龄
            this.age = age;
        }
    }


    //快速生成get/set方法
    //快捷键：alt + insert  选择get和set，再选择需要生成的get和set方法
}


/*
    封装的作用
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统可维护性增加了
    5.属性私有，使用set和get方法
*/
/*
        //调用代码：

public class Application {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();

        student1.setName("David");
        System.out.println(student1.getName());  //David
        student1.setAge(100);
        System.out.println(student1.getAge());  //100


        student2.setName("YZ");
        System.out.println(student2.getName());  //YZ
        //输入不合法的年龄
        student2.setAge(150);
        System.out.println(student2.getAge());  //3

    }
}
*/

继承

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

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

Java中类只有单继承，没有多继承。

继承是类和类之间的一种关系，除此之外，类和类之家你的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上来讲应该具有“is a”的关系。

举例：

父类：Person类

package David.Study.Oop.Demo03;

//在java中，所有的类，都默认直接或间接继承Object
//人   父类：基类
public class Person {

    //public
    //protected
    //default
    //private
    public int money = 10_0000;

    public void say(){
        System.out.println("说话");
    }
}

子类：Student类

package David.Study.Oop.Demo03;

//Student  is  Person   派生类：子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{

}

程序调用：

package David.Study.Oop;

import David.Study.Oop.Demo03.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();  //说话
        System.out.println(student.money);  //100000

    }
}

Super关键字

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法

super和this的区别：

代表的对象不同：
- this：代表本身调用者这个对象
- super：代表父类对象的应用
前提：
- this：没有继承也可以使用
- super：只有在继承条件下可以使用
构造方法：
- this()：本类的构造
- super()：父类的构造

父类：Person类

package David.Study.Oop.Demo03;

//在java中，所有的类，都默认直接或间接继承Object
//人   父类：基类
public class Person {
    public Person() {
        System.out.println("Person无参构造执行了");
    }

    //用关键字Private所修饰的属性或者是方法，是无法被继承的

    protected String name = "David";

    public void print(){
        System.out.println("Person");
    }
}

子类：Student类

package David.Study.Oop.Demo03;

//Student  is  Person   派生类：子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{

    public Student() {
        //隐藏代码：默认先调用了父类的无参构造
        //super();调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参构造执行了");
    }

    private String name = "D_David";

    public void test1(String name){
        System.out.println(name);  //YZ
        System.out.println(this.name);  //D_David
        System.out.println(super.name);  //David
    }

    public void print(){
        System.out.println("Student");
    }

    public void test2(){
        print();  //Student
        this.print();  //Student
        super.print();  //Person
    }

}

程序调用：

package David.Study.Oop;

import David.Study.Oop.Demo03.Student;

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

        Student student = new Student();
        student.test1("YZ");
        student.test2();
    }
}

输出结果为：

Person无参构造执行了
Student无参构造执行了
YZ
D_David
David
Student
Student
Person

进程已结束，退出代码 0

方法重写

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

方法名必须想同；
参数列表必须相同；
修饰符：范围可以扩大，不能缩小； public>protected>default>private；
抛出的异常：范围可以被缩小，但不能扩大；
子类的方法和父类一致，但是方法体不同！

为什么要重写：

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

快捷键：Alt + Insert ：override；

父类：B类

package David.Study.Oop.Demo04;

//父类
public class B {

    /*  静态方法时
    public static void test(){
        System.out.println("B=>test()");
    }
     */

    //非静态方法时
    public void test(){
        System.out.println("B=>test()");
    }
}

子类：A类

package David.Study.Oop.Demo04;

//继承
public class A extends B{

 /*   静态方法时
    public static void test(){
        System.out.println("A=>test()");
    }
  */

    //非静态方法时
    //Override 重写
    @Override //注解：有功能的注释！
    public void test(){
        System.out.println("A=>test()");
    }
}

程序调用：

package David.Study.Oop;

import David.Study.Oop.Demo04.A;
import David.Study.Oop.Demo04.B;

public class Application {

    //静态的方法和非静态的方法区别很大
    //静态方法：方法的调用只和左边，定义的数据类型有关，因为在类加载中就已经加载完成
    //非静态才叫重写
    public static void main(String[] args) {

/*  当A和B中的方法为静态方法时所使用的语句及输出结果：
        A a = new A();
        a.test();  //A=>test()

        //父类的引用指向了子类
        B b = new A();
        b.test();  //B=>test()
 */
    //当A和B中的方法为非静态方法时所使用的语句及输出结果：
        A a = new A();
        a.test();  //A=>test()

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

多态

即同一个方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类或有关系的类）。

多态注意事项：

多态是方法的多态，属性没有多态性
父类和子类，有联系（注意类型转换异常（ClassCastException））
存在条件：继承条件，方法需要重写，父类引用指向子类对象
- Father f1 =new Son();
- static方法，属于类，它不属于实例，无法被重写
- final修饰的方法无法被重写
- private修饰的方法无法被重写
当父类和子类存在相同的方法时，调用子类已重写过的方法。

举例：

Person类：

package David.Study.Oop.Demo05;

public class Person {

    public void run(){
        System.out.println("这是父类");
    }
}

Student类：

package David.Study.Oop.Demo05;

public class Student extends Person{

    @Override
    public void run() {
        System.out.println("这是子类方法");
    }

    public void eat() {
        System.out.println("这是子类的eat方法");
    }
}

程序调用：

package David.Study.Oop;

import David.Study.Oop.Demo05.Person;
import David.Study.Oop.Demo05.Student;

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

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定
        //Student能调用的方法都是自己的或者是继承父类的
        Student s1 = new Student();
        //Person父类型，可以指向子类，但不能调用子类独有的方法
        Person s2 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型
        //和右边关系不大
        s1.run();//输出：这是子类方法 //子类重写了父类的方法
        s2.run();//输出：这是子类方法

        s1.eat();//输出：这是子类的eat方法
        //s2.eat();  报错，父类不能调用子类独有的方法
        ((Student)s2).eat();//输出：这是子类的eat方法
    }
}

instanceof

instanceof：判断一个对象是什么类型。

举例：

Person类：

package David.Study.Oop.Demo05;

public class Person {

}

Teacher类：

package David.Study.Oop.Demo05;

public class Teacher extends Person {
    
}

Student类：

package David.Study.Oop.Demo05;

public class Student extends Person{

}

程序调用：

package David.Study.Oop;

import David.Study.Oop.Demo05.Person;
import David.Study.Oop.Demo05.Student;
import David.Study.Oop.Demo05.Teacher;

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

        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        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
        System.out.println("==================");

        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);  编译时就报错（同级之间不能进行比较和转换）
        System.out.println("==================");

        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);编译报错
    }
}

类型转换

子类转换为父类：可能丢失自己本来的一些方法
把子类转换为父类，向上转型，不用强转，可能丢失自己本身的一些方法
把父类转换为子类，向下转型，强制转换
方便方法的调用（降级或者升级就能调用一些方法了）减少重复的代码

David--

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java关于面向对象基础概念

Java入门基础（六）面向对象面向过程和面向对象：面向过程思想步骤清晰简单，第一步做什么，第二步做什么面向过程适合处理一些较为简单的问题面向对象思想物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题！对面描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，任然需要面向过程的思路去处
复制链接

扫一扫