JAVA 面向对象

JAVA 面向对象编程

什么是面向对象

本质

以类的方式组织代码，以对象的组织（封装数据）。

三大特性

• 封装
• 继承
• 多态

类

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

• 对象是抽象概念的具体实例。

创建与初始化对象

• 使用new关键字创建对象
• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点
  • 必须和类的名字相同
  • 必须没有返回类型，也不能写void

/*
以下是一个创建类的实例
*/
public class Student{
    String name;
    int age;
    public void study(){
        System.out.println(this.name+"is studying");
    }
}

类的构造方法

• 使用new关键字，本质上是在调用构造方法。

• 构造方法一般用来初始化对象的值。

• 一个类即使什么都不写，内容为空，它也会默认存在一个和类名相同的构造方法，构造方法分无参构造和有参构造，

• 一旦定义了有参构造，无参构造就必须显式定义。

• IDEA使用alt+Insert可以快速生成构造方法。

封装

类中有private的属性时，外部不能直接访问该属性。必须提供一些可以操作这个属性的方法，提供一些public的get、set方法

/*
下面是封装的例子
*/
public class Student{
    String name;
    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;
    }
}

IDEA可以使用快捷键alt+insert Getter and Setter 快速生成get和set方法。

继承

• 继承的本质是对某一批类的抽象
• extends的意思是“扩展”，子类是父类的扩展。
• java中类只有单继承，没有多继承。
• 在java中所有的类都默认继承了object类
• 子类继承了父类，就会拥有父类除了private的全部方法。
• this()是本类的构造，super()是父类的构造。

例

public class Person{
    
}

public class Student extends Person{
    
}
// Student is Person Student继承了Person

方法的重写

• 重写需要有继承关系，子类重写父类的方法。
• 参数列表必须相同
• 修饰符：范围可以扩大： private > protected >Default > private
• 抛出的异常：范围可以被缩小，但不能被扩大。
• 重写：子类的方法和父类必须要一致，方法体不同。
• IDEA使用alt+insert Override Methods可以快速生成重写方法

父类和子类有相同的静态方法，在调用时只和定义的数据类型有关。

 public static void main(String[] args) {
     A a = new A();
     a.test();//A
     B b = new A();
     b.test();//B	
    }

多态

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

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

• 多态存在的条件

  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象

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

• instanceof

• 父类可以指向子类，但是不能调用子类独有的方法。

抽象类

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

public abstract class Person {   
    abstract void doSomething();
}

public abstract  class Student extends Person {
   
    @Override
    void doSomething() {
        System.out.println("dosomething!!");
    }
}

接口

• 接口只有规范，自己无法写方法，专业的约束，约束和实现分离，定义的是一组规则。

• 声明接口的关键字是interface

• 接口中所有定义都默认是public abstract的

• 实现了接口的类，就必须重写接口中的方法。

• 接口不能被实例化，接口中没有构造方法。

• implements可以实现多个接口，使用逗号隔开。

//定义一个接口
public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

//定义一个实现类
public class UserServiceImpl 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) {

    }
}