JAVA学习笔记第五部分——Java面向对象编程

最新推荐文章于 2023-12-10 13:30:18 发布

细谈人生一载

最新推荐文章于 2023-12-10 13:30:18 发布

阅读量201

点赞数

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/qq_62581191/article/details/129585847

版权

本文详细介绍了Java中的面向对象编程思想，包括面向过程与面向对象的区别，类和对象的概念，对象的创建过程，以及面向对象的三大特性——封装、继承和多态。同时，讲解了抽象类和接口在Java中的作用，强调了它们在代码组织和设计中的重要性。

摘要由CSDN通过智能技术生成

Java面向对象编程

Java的核心思想就是OOP（Object Oriented Pragramming）

一.解析面向对象的思想
二.详解类和对象
三.对象的创建过程
四.面向对象的三大特性：封装、继承、多态
五.抽象类和接口

一.解析面向对象的思想

在了解面向对象的思想之前，让我们先了解一下面向过程的思想

面向过程的思想

步骤清晰简单，即第一步做什么，第二步做什么…
面向过程适合处理一些较为简单的问题
属于线性思维

面向对象的思想

物以类聚，分类的思维模式，思考问题前首先会考虑解决问题需要那些分类，然后对这些分类进行单独思考。最后进行面向过程的思索。
适合处理复杂的问题，适合处理需要多人协作的问题

总结：对于描述复杂的问题，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。最后，才对某个分类下的细节问题进行面向过程的思索

二.认识对象和类

从认识论角度考虑“对象”和“类”，是先有“对象”后有“类”。“对象”是具体的事物，“类”是抽象的事物，“类”是对“对象”的抽象。
从代码运行角度考虑“对象”和“类”，是先有“类”后有“对象”。“类”是“对象”的模板。

类和对象的关系

类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但是并不能代表某一具体的事物，动物、植物、手机、电脑、微生物…这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体事例张三家里面的旺财就是狗的一个具体的实例，它能够体现出特点，展现出实例的功能，而不是一个抽象的概念

三.对象的创建过程

使用new关键字创建对象

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

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

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

public class demo_02 {
    public static void main(String[] args) {
        //实例化这个类  new
        //对象类型 对象名 = 对象值。对象值变成了一个实例化对象
        Student student = new Student();
        student.say();
    }
}

//学生类
public class Student {
    public Student() {

    };//构造器

    //非静态方法
    public void say(){
        System.out.println("学生说话了");
    }
}

详细请看：

版权声明：本文为CSDN博主「书呆子Rico」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/justloveyou_/article/details/72466416

四.面向对象的三大特性：封装、继承、多态

封装

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

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

package JAVASE.object_oriented.demo_04;

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

        s1.setName("古天乐");

        String name=s1.getName();
        System.out.println(name);

        s1.setAge(20);//不合法
        System.out.println(s1.getAge());
    }
}

package JAVASE.object_oriented.demo_04;

//类
public class Student {
    //属性私有，但会提供一些平public的get、set
    private String name;
    private int age;
    private int id;
    private char sex;

    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return this.age;
    }
    public void setAge(int age){
        if(age>0 && age<150){
            this.age=age;
        }
        else {
            this.age=3;
        }
    }
}
/*
封装的好处：
    （1）提高程序的安全性
    （2）隐藏代码的细节
    （3）统一接口
    （4）增强了系统的可维护性

方法的重载
    两个方法完全相同的条件：方法名称相同，参数列表相同
 */

继承

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

extends的意思是“扩展”，子类是父类的扩展
Java中只有单继承，没有多继承。就像一个儿子只有一个爸爸，一个爸爸能有多个儿子
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is a”的关系

多态

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

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件

①有继承关系
②子类重写父类
③父类引用指向子类对象

注意：多态是方法的多态，属性没有多态

拓展:instanceof（引用类型转换）

父类引用指向子类对象
把子类转换为父类，向上转型
把父类转化为子类，向下转型，需要强制转换

代码解释如下：

package JAVASE.object_oriented.demo_07;

public class Application {
    public static void main(String[] args) {
        //类型之间的转换：基本类型转换  父子
        //高转低  强制转换;低转高   自然转换


        //高转低（向下转型）
        Person chinese=new Student();//Student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        ((Student)chinese).go();

        //低转高（向上转型）    子类转父类可能丢失自己本来的一些方法
        Person person=new Student();
        person.run();


//Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object=new Student();

//        System.out.println(x instanceof y);//能否编译通过取决于x与y是否有关系


        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 Person();
        System.out.println(person_ instanceof Student);//false
        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);//编译报错

    }
}

package JAVASE.object_oriented.demo_07;

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

package JAVASE.object_oriented.demo_07;

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }

}

package JAVASE.object_oriented.demo_07;

public class Teacher extends Person{

}

go
run
true
true
true
false
false
=======================
false
true
true
false
=======================
true
true
true

五.抽象类和接口

抽象类

abstract修饰符可以用来修饰方法，也可以用来修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

抽象类可以没有抽象方法，但是抽象方法的类一定要声明为抽象类
抽象类，不能使用new关键字来创建对象，它是用来记录子类继承的
抽象方法，只有方法的声明，没有方法的实现，它是它是用来记录子类实现的
子类继承抽象类，那么就必须实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

接口

普通类	抽象类	接口
只有具体实现	只有具体实现和规范（抽象方法）	只有规范

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是… 则必须能…”的思想。例如：如果你是天使，则必须能飞；如果你是好人，则必须做好事…
接口的本质是契约，就像人间的法律一样，制定好后大家遵守
面向对象的精髓是对“对象”的抽象，最能体现这一点的就是接口

声明类的关键字是class，声明接口的关键字是interface

细谈人生一载

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
JAVA学习笔记第五部分——Java面向对象编程

Java面向对象编程
复制链接

扫一扫