面向对象

面向对象

一、面向对象的概念

面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物使用对象的关系来描述事物之间的联系，这种思想就是面向对象。

提到面向对象，自然会想到面向过程，面向过程就是分析解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候一个一个依次调用就可以了。面向对象则是把解决的问题按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。当然，一个应用程序会包含多个对象，通过多个对象的相互配合来实现应用程序的功能，这样当应用程序功能发生变动时，只需要修改个别的对象就可以了，从而使代码更容易得到维护。

 

二、面向对象的特点

面向对象的特点主要可以概括为封装性、继承性和多态性，接下来针对这三种特性进行简单介绍。

 

1、封装性

封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。例如，用户使用电脑，只需要使用手指敲键盘就可以了无须知道电脑内部是如何工作的，即使用户可能碰巧知道电脑的工作原理，但在使用时，并不完全依赖电脑工作原理这些细节。

2、继承性

继承性主要描述的是类与类之间的关系，通过继承，可以在无须重新编写原有类的情况下，对原有类的功能进行扩展。例如，有一个汽车的类，该类中描述了汽车的普通特性和功能，而轿车的类中不仅应该包含汽车的特性和功能，还应该增加轿车特有的功能，这时，可以让轿车类继承汽车类，在轿车类中单独添加轿车特性的方法就可以了继承性不仅增强了代码复用性，提高了开发效率，而且为程序的修改补充提供了便利。

 

3、多态性

多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。例如，当听到“Cut”这个单词时，理发师的行为是剪发，演员的行为是停止表演不同的对象，所表现的行为是不一样的

 

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

break:跳出switch，结束循环

return:结束方法，返回一个结果

 

构造器

public class Person {
    String name;
    int age;
​
    public Person() {              //空参构造
    }
​
    public Person(String name,int age) {            //有参构造
        this.name = name;
        this.age=age;
    }
}

如果有了有参构造，而且需要调用空参构造，则需要显示的写出空参构造

alt+insert快捷键自动生成构造器 按住ctrl可以进行多选

 

封装

属性私有，get和set

//封装
public class Student {
    private String name;
    private int age;
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
}

 

this和super

super注意点：

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

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

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

Vs this:

代表的对象不同：

this:本身调用者这个对象

super:代表父类对象的应用

前提：

this:没有继承也可以使用

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

构造方法：

this():本类构造

super():父类的构造

public class Person {
    public String name;
​
    public void print(){
        System.out.println("大白");
    }
    public void test(){
        print();
    }
}
​
public class Student extends Person{
    @Override
    public void print() {
        System.out.println("dabai");
    }
​
    @Override
    public void test() {
        this.print();
        super.print();
    }
}

 

重写

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

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大但不能缩小：public >protected>default>private

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

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

为什么要重写

父类的功能，子类不一定需要

 

多态

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

2.有父子类联系

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

 

public class Student {
    //优先与构造方法
    {
        System.out.println("匿名代码块");
    }
    //优先执行，且只执行一次
    static {
        System.out.println("静态代码块");
    }
​
    public Student(){
        System.out.println("构造方法");
    }
​
    public static void main(String[] args) {
        Student s=new Student();
    }
}

 

抽象类

子类继承抽象的父类，必须重写父类中的抽象方法

 

接口

//interface 定义的关键字 ，接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的  public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
​
//类可以实现接口  implements 接口
//实现了接口的类，需要重写接口中的方法   接口可以实现多继承
//接口不能被实例化
public class UserServiceImp implements UserService {
    @Override
    public void add(String name) {
​
    }
    @Override
    public void delete(String name) {
​
    }
​
    @Override
    public void update(String name) {
​
    }
​
    @Override
    public void query(String name) {
​
    }
}