Day 004_面向对象编程

面向对象编程OOP

面向过程思想（线性思维）

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

面向对象思想

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

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

面向对象编程：Object-Oriented Programming OOP

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

抽象

三大特性：

• 封装：
• 继承
• 多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

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

类 对象

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

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

扫描二维码关注公众号，回复： 13244072 查看本文章

新建个学生类 以类的方式组织代码

//学生类
public class Sstudent {
    
    
    //属性：字段
    String name;//默认为null
    int age;//默认为0

    //方法
    public void study(){
    
    
        System.out.println(this.name +"学习");
    }
}

使用new关键字创建对象

以对象的形式组织（封装）数据

//一个项目应该只存在一个main方法
public class Demo {
    
    
    public static void main(String[] args) {
    
    
        //类：抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //sstudent对象就是一个Sstudent类的具体实例
        Sstudent sstudent = new Sstudent();
        Sstudent xiaoming = new Sstudent();
        Sstudent xiaohong = new Sstudent();

        xiaoming.name="xm";
        xiaoming.age= 3;
        
        System.out.println(xiaoming.name);//xm
    }
}

对象的创建和使用

构造器

也称构造方法，在进行创建对象的时候必须要调用的

特点：

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

一个类即使什么都不写，也会存在一个构造器

//class文件：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

public class Person {
    
    
    public Person() {
    
    
    }
}

public class Person {
    
    
    String name;

    //实例化初始值
    // 1.使用new关键字，本质是在调用构造器 2.构造器用来初始化值
    public Person(){
    
    
    }//无参

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

作用：

1. 使用new关键字，本质是在调用构造
2. 构造器用来初始化对象的值

**快捷键：**Alt + Insert 生成构造器 有参 无参

**注意点：**定义了有参构造后，如果想使用无参构造，显示的定义一个无参的构造。

**对象的属性：**构造器 Person hxh = new Person(); hxh.name

对象的方法：hhx.sleep()

对象的引用

引用类型：除了基本类型（8）外

对象是通过引用来操作的：栈----->堆（地址）真实操作是堆

对象的属性

字段field 成员变量

默认初始化： 数字：0 0.0

​ char：u000

​ boolean：false

​ 引用：null

​ 修饰符 属性类型 属性名 = 属性值

类

• 静态的属性

• 动态的方法

三大特性

封装

高内聚（类的内部数据操作细节自己完成），低耦合（仅暴露少量的方法给外部使用）

封装：数据的隐藏：应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问

属性私有 get/set private

public class Demo04 {
    
    

    //属性私有
    private String name;
    private int id;
    private char sex;

    //提供一些可以操作这个属性的方法
    //提供一些public的get set方法
    //get 获得这个数据  set  给这个数据设置值
    public String getName(){
    
    
        return this.name;
    }
    public void setName(String name){
    
    
        this.name = name;
    }
}

import oop.Demo04;

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

        s1.setName("hxh");

        System.out.println(s1.getName());
    }
}

alt + insert getter and setter

意义：

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

package oop;

public class Demo04 {
    
    

    //属性私有
    private String name;
    private int id;
    private int age;
    private char sex;

    //提供一些可以操作这个属性的方法
    //提供一些public的get set方法
    //get 获得这个数据  set  给这个数据设置值
    public String getName(){
    
    
        return this.name;
    }
    public void setName(String name){
    
    
        this.name = name;
    }

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        if (age>120 || age < 0){
    
    
            this.age = 3;
        }else{
    
    
            this.age = age;
        }

    }
}

import oop.Demo04;

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

        s1.setName("hxh");

        System.out.println(s1.getName());

        s1.setAge(-2);
        System.out.println(s1.getAge());
    }
}

继承

extends：扩展 子类是父类的扩展，子类继承父类就会拥有父类的全部方法

public class Student extends Person {
    
    }

继承是类和类之间的一种关系

public—protected—default—private

Ctrl + H 打开树结构

Java中只有单继承。一个子只有一个父，一个父可以有多个子

在Java中，所有的类都默认直接或者间接继承Object类

私有的东西无法被继承

父类：

package oop.demo05;

//父类
public class Person {
    protected String name = "hxh";
}

子类：

//派生类 子类
public class Student extends Person {
    
    
    private String name = "Han";
    public void test(String name){
    
    
        System.out.println(name);
        System.out.println(this.name);//this 调用自己
        System.out.println(super.name);//super 调用父类
    }
}

主函数：

public class Application {
    
    
    public static void main(String[] args) {
    
    
        Student student = new Student();
        student.test("韩");
    }
}

输出结果： 韩
Han
hxh

super注意点：

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

super与this：

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

重写

重写都是方法的重写，与属性无关。

重写只与非静态有关，不能用static静态的

重写关键词是public。

public class B {
    
    
    public void  test(){
    
    
        System.out.println("B=>test()");
    }
}

public class A extends B {
    
    
    @Override//重写（注解：有功能的注释）
    public void test() {
    
    
        System.out.println("A=>test()");
    }
}

public class Application {
    
    

    //静态方法和费静态方法区别很大
    public static void main(String[] args) {
    
    
        //方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();//A

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

结果： A=>test()
A=>test()

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

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大，但是不能缩小。public>protected>default>private
4. 抛出的异常：范围可以被缩小，但不能扩大：ClassNoteFoundException----->Exception(大)

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

为什么需要重写

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

   Alt + Insert—>override

子类没有重写父类的，调用父类。子类重写了父类的，调用子类。

多态

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

动态编译：类型：可扩展性

注意事项：

1. 多态是方法的多态，属性没有多态。
2. 父类和子类有联系。转换 类型转换异常：ClassCastException
3. 存在的条件：继承关系；方法需要重写；父类的引用指向子类对象。 Father s1 = new Son()

• static属于类，不属于实例，不能重写

• final常量的，不能重写

• private私有的，不能重写

instanceof

多态：

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型，不用强制转换
3. 把父类转化为子类，需强制转换，可能会丢失一些方法
4. 方便方法的调用，减少重复的代码

static

public class Person {
    
    
    
    {
    
    
        //代码块（匿名代码块）
    }
    static {
    
    
        //静态代码块
    }
}

public class Person {
    
    

    {
    
    
        System.out.println("匿名代码块");//2 赋初始值
    }

    static {
    
    
        System.out.println("静态代码块");//第1个执行并且只执行一次
    }

    public Person() {
    
    
        System.out.println("构造方法");//3
    }

    public static void main(String[] args) {
    
    
        Person person1 = new Person();
        System.out.println("==============");
        Person person2 = new Person();
    }
}

结果： 静态代码块
匿名代码块
构造方法

​ 匿名代码块
​ 构造方法

import static java.lang.Math.random;//加static，静态导入包
import static java.lang.Math.PI;

public class Test {
    
    

    public static void main(String[] args) {
    
    
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类

abstract 抽象类

抽象类的所有方法，继承了抽象类的子类都必须要实现抽象类的方法

extends：单继承

​ 接口可以多继承

1. 不能new抽象类，只能靠子类去实现它：约束
2. 抽象方法必须在抽象类中
3. 抽象类里可以有普通方法

接口

只有规范，自己无法写方法 专业的约束 约束和实现分离：面向接口编程

接口的本质是契约

interface

接口中的所有定义其实都是抽象的public abstract

public interface UserService {
    
    
    public abstract void run();//不写public abstract也可以，默认是这样
}

接口都需要有实现类

类可以实现接口 implements 接口

实现了接口的类就需要重写接口中的方法

public interface TimeService {
    
    
    void timer();
}

public interface UserService {
    
    
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

public class UserServiceImpl implements UserService,TimeService{
    
    

    @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 timer() {
    
    

    }
}

接口的作用

1. 约束
2. 定义一些方法，让不同的人实现
3. 方法都是public abstract
4. 常量：public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

内部类

在一个类的内部再定义一个类