面向对象简介

Mr_ming_a_probie

已于 2022-09-29 18:32:40 修改

阅读量48

点赞数

文章标签： java 开发语言

于 2022-09-29 18:32:07 首次发布

本文链接：https://blog.csdn.net/Mr_ming_a_probie/article/details/127111873

版权

文章目录

1、初识面向对象：
- - 面向过程和面向对象
2、方法：
3、对象的创建分析
- - 类和对象的关系
  - 创建与初始化对象：
4、面向对象三大特性
5、抽象类和接口
6、接口：

1、初识面向对象：

面向过程和面向对象

面向过程思想：面向过程是一种以过程为中心的编程思想，是一种自顶而下的编程模式。

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

面向对象思想：物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的思索。

面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

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

什么是面向对象：

对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。

面向对象编程（OOP-Object Oriented Programming）
本质：以类的方式组织代码，以对象的组织（封装）数据。

2、方法：

方法：方法本质上就是完成一个特定功能的代码片段。

方法的结构：修饰符返回类型方法名（形参类表）{

方法体（方法的具体功能）

return 返回值

}

//返回值类型为String，需要写一个return***，来返回，return的类型要和返回值类型一致
public String sayHello(){
return "hello,world!";
}

//如果是无返回值类型的方法，可以直接写一个return返回也可以不写return
public void noReturn(){
return;
}

return和break的区别：

return：代表结束方法，返回一个结果，可以为空，可以为别的。
break：结束循环，跳出当前循环，继续按顺序走代码

静态方法和非静态方法：

静态方法：static 和类一起加载的。调用方法：类名().方法()
非静态方法：实例化之后才存在。调用方法：new 类名().方法() 万能公式：对象类型对象名 = 对象值；

方法的重载：

方法重载发生在同一个类中，方法名相同，参数列表不同（参数类型、参数个数、参数顺序）。在调用方法时，通过实参来决定执行那个重载方法。
方法重载，方法名和方法参数的类型会参与编译，而方法参数的名称和方法的返回类型不会参与编译，所以，方法重载和方法返回类型，以及方法参数名无关。

/**
 * 重载方法
 * 方法的调用会根据传入的参数匹配对应的方法
 * 重载与方法名和返回类型无关因为他们不参与编译
 */
public class LoadTest {

    public int load(int a){
        return a;
    }
    //参数个数   返回类型不同
    public int  load(int a,int b){
        return a;
    }
    //参数类型不同
    public String load(double a){
        return "";
    }
    //参数类表的顺序不同但是需要不同类型的参数
    public int load(int a,double b){
        return (int) a;
    }
    public int load(double b,int a){
        return (int) a;
    }
    //类型相同时会默认相同方法
    /*public int  load(int b,int a){
        return a;
    }*/

}

3、对象的创建分析

类和对象的关系

类是一种抽象概念，它是对某一类事物整体描述或者说是定义，但是并不能代表某一个具体的事物。
对象是一个具体的实物，他是抽象概念的具体实例。

结论：类是抽象模板，对象是类的实例。

创建与初始化对象：

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

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

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

作用：

new的本质在调用构造方法

初始化对象的值
注意：定义了有参构造之后，如果想使用无参构造，必须显式定义一个无参的构造

package com.example.demo.test;

public class Run {

    public Run() {
        System.out.println("无参构造调用了");
    }

    public void run(){
        System.out.println("跑的快");
    }

    public static void main(String[] args) {
        Run run = new Run();
    }
}

打印结果：无参构造调用了

4、面向对象三大特性

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

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

4.1、封装：

通常应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。在一个方法中就是：属性私有（修饰符private）,使用get/set 方法操作数据
封装的意义：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加了

4.2、继承：

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法（private修饰的属性不能继承），或子类从父类继承方法，使得子类具有父类相同的行为。

继承实现了 is-a 关系，继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extands来表示 extands的意思是扩展，子类是父类的扩展

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

this和super的使用

this：本身调用者对象
super：父类对象的引用

使用条件：this没有继承也可以使用，super只有在继承条件下才可以使用。

注意：子类实例化时默认调用父类的构造方法

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

方法重写：

静态方法和非静态的方法区别很大！
静态方法：方法的调用只和左边定义的数据类型有关

重写：方法必须一致，方法体不同。

前提：需要有继承关系，是在非静态情况下，子类重写父类的方法。

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大： public > Protected > Default > private
抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException -->Exception(大)

4.3、多态：

多态：同一个行为具有不同的表现形式或形态的能力

规则：

一个对象的编译类型与运行类型可以不一致
编译类型在定义对象时，就确定了，不能改变，而运行类型是可以变化的
编译类型看定义对象时 = 号的左边，运行类型看 = 号的右边
多态是方法的多态，属性没有多态

package com.example.demo.test;
//
public class Sports {
    //无参构造
    public Sports() {
        System.out.println("父类的无参构造");
    }

    public void run(){
        System.out.println("跑步运动");
    }

    public static void load(){
        System.out.println("快走运动");
    }
}


package com.example.demo.test;

/**
 * 跑步运动
 */
public class Run extends Sports{

    public Run() {
        //super默认调用，使用时必须放在子类构造方法的第一行
        super();
        System.out.println("子类无参构造调用了");
    }
    @Override //重写父类方法
    public void run(){
        System.out.println("开始跑步");
        //super 用于引用父类的对象
        super.run();
        //this 代表当前类
        this.test();
    }
    //静态方法属于类的，他与类一起加载，不参与重新
    public static void load(){
        System.out.println("开始快走");
    }
    //子类扩展
    public void test(){
        System.out.println("this当前类的引用");
    }
}
package com.example.demo.test;


package com.example.demo.test;


public class OperateTest {
    public static void main(String[] args) {
        //子类创建对象时 默认先调用父类的无参构造方法
        Run run = new Run();
        //父类的引用指向子类的类型！
        Sports run2=new Run();
        //对象能执行的方法主要看左边的类型！
        //子类可以用父类的，但是父类不能用子类的
        run.run();
        run2.run();
        //静态方法的调用只跟左边定义的类型有关
        run.load();
        run2.load();

        run.test();
        //父类不可以调用子类的必须强制性转换子类之后才可以使用
        ((Run) run2).test();

        //instanceof is a判断 是否存在父子关系 继承
        //Object 是所有对象的父类
        Object object=new Sports();
        System.out.println(object instanceof Sports);
        System.out.println(run2 instanceof Run);

    }

}

父类的无参构造
子类无参构造调用了
父类的无参构造
子类无参构造调用了
开始跑步
跑步运动
this当前类的引用
开始跑步
跑步运动
this当前类的引用
开始快走
快走运动
this当前类的引用
this当前类的引用
父类的无参构造
true
true

5、抽象类和接口

抽象类：
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

//abstract 抽象类 extends是单继承（接口可以多继承）
public abstract class Action {
    //约束
    //abstract 抽象方法，只有名字，没有方法的实现。
    //子类必须实现它的方法，除非子类也是抽象类。
    public abstract void doSomething();
    /*
    1.不能new抽象类，只能靠子类来实现它：约束！
     */
    public void go(){
        System.out.println("hello");
    }
}

public class A extends Action{
    @Override
    public void doSomething() {
    }
}

6、接口：

接口就是规范，定义的是一组规则。

体现了现实世界中“如果你是…则必须能”的思想，如果你是天使，则必须能飞，如果你是汽车，则必须能跑。
接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对具备了抽象能力的语言，（C++，Java，C#）等，就是说因为设计模式所研究的，实际上就是如何合理的去抽象。
接口中所有定义都是抽象的接口的关键字是 insterface

public interface TimeService {
    void time();
}
public interface UserService {
    //接口中所有定义都是抽象的 public abstract
    //接口需要实现类
    //常量~public static final省略
    int age = 99;
    public abstract void run(String name);//public abstract可以省略
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
//抽象类用extends
//接口用implements,可以链接多个接口
//实现了接口的类就需要重写接口中的方法！
//多继承~利用接口实现了多继承！
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void run(String name) {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time() {

    }
}