面向对象：封装、继承、多态

面向过程

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

面向对象

面向对象：Object- Oriented Programming OOP
面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据
抽象
三大特性：
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模版。

类与对象的关系

类是一种抽象的数据类型，他是对某一类事物整体描述/定义，但是并不代表你某一个具体的事物。
对象是抽象概念的具体实例

创建与初始化对象

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

构造器

和类名相同
没有返回值
作用：1.new本质在调用构造方法 2.初始化对象都值
注意点：定义有参构造之后，如果使用无参构造，需要显式定义一个无参构造
windows 记住快捷。 alt + insert
mac ：command + N

创建对象内存分析

总结：类与对象

类与对象：
- 类是一个模版：抽象，对象是一个具体的实例
方法：定义，调用
对象的引用：
- 引用类型、基本类型（8大类）
- 对象是通过引用来操作的：栈------》堆
属性默认值：

默认初始值：

数字：0 0.0

char：u0000

Boolean:false

引用：null

修饰符属性类型属性名 = 属性值
对象的创建和使用
- 必须使用new关键字创造对象，构造器 Person person = new Person();
- 对象的属性 person.name
- 对象的方法. person.sleep()

类：

静态的属性属性
动态行为方法

package com.sxl.oop.demo02;

public class Student {

    //属性：字段
    String name;
    int age;

    //一个类即使什么都不写，也会存在一个无参构造
    
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    public Student() {
        this.name = "songxinglei";
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //有参构造：一旦定义了有参构造器，必须显式定义一个无参构造
    public Student(String name) {
        this.name = name;
    }
    //方法
    public void study(){
        System.out.println("学习！");
    }
}

封装

该露的露，该藏的藏
- 我们程序设计要追求“高内聚，低耦合“。高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住这句话就够了：属性私有；get/set

package com.sxl.oop.demo03;

//属性私有；get、set
public class Student {
    private String name;
    private int age;
    private char sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extands的意思是“扩展”。子类是父类的扩展
java中类只有单继承，没有多继承
继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲因该具有“ is a”的关系
object类
super

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

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

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

VS this

1.this：本身指调用者这个对象；super：代表父类对象的引用

2.this：没有继承可以使用；super：只能在继承条件下才可以使用

3.构造方法：

this（）；本类的构造

super（）；父类的构造
方法的重写：需要有继承关系，子类重写父类的方法
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小：public > protected >default > private
4. 抛出异常：范围可以缩小，但不能扩大
重写，子类的方法和父类的方法一致，方法体不同

package com.sxl.oop.demo04;

//父类：基类
public class Person {

    protected String name = "Person";

    public Person() {
        System.out.println("调用了父类无参构造器！");
    }

    public void say() {
        System.out.println("讲话");
    }
    //私有的东西无法继承
    private void hello(){
        System.out.println("hello");
    }
}


package com.sxl.oop.demo04;

//子类 studetn is person
public class Student extends Person {
    private String name = "student";

    public Student() {
        //即使不写super（）；第一行也会隐藏代码，调用父类的无参构造器
        super(); //调用父类无参构造器，必须写在子类构造器第一行
        System.out.println("调用了子类的无参构造器！");
    }

    public void test1(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    public void test2(){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
        super.say();
    }
}

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）
多态存在的条件：
1. 有继承关系
2. 子类重写父类的方法
3. 父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性
instanceof （类型转换）-----引用类型。判断一个对象是什么类型
扩展（以下修饰的方法不能重写）：
- static 方法--属于类，不属于实例
- final 常量
- private 私有方法

  /*
          //一个类的实际类型是确定的
//        new Student();
//        new Person();

        //指向对象的引用类型不确定
        //Student 能调用自己的方法或者调用继承父类的方法
        Student s1 = new Student();
        //Person  父类，可以执行子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        s1.test();
        s2.test(); //子类重写了父类的方法，执行子类的方法
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s1.eat();
     */

抽象类

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

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

package com.sxl.oop.demo08;

//abstract 抽象类
//1. 不能 new 这个抽象类，只能通过子类去实现他：约束
//2. 抽象类中可以写普通方法
//3。 抽象方法必须在抽象类中
public abstract class Action {

    //抽象方法，只有方法名，没有方法实现
    public abstract void doSomething();

    public void go (){
        System.out.println("go go go");
    }

    public Action() {
        System.out.println("父类构造方法");
    }
}

package com.sxl.oop.demo08;

public class A extends Action{
    @Override
    public void doSomething() {
        System.out.println("song");
    }

    public static void main(String[] args) {
        Action a = new A();

    }
}

接口

约束
定义一些方法，让不同的类去实现
方法都是 public abstract
属性都是。public static final
接口不能被实例化，接口中没有构造方法
Implements 可以实现多个接口
一个类实现一个接口，就必须要重写接口中的方法

package com.sxl.oop.demo09;

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


package com.sxl.oop.demo09;

public interface OrderService {
    void buy ();
}

package com.sxl.oop.demo09;

//利用接口实现多继承～
public class UserServiceImpl implements UserService,OrderService{
    @Override
    public void add() {

    }

    @Override
    public void delete() {

    }

    @Override
    public void update() {

    }

    @Override
    public void query() {

    }

    @Override
    public void buy() {

    }
}

posted @ 2021-07-05 11:36 songxinglei 阅读(101) 评论(0) 收藏举报

刷新页面返回顶部

songxinglei

面向对象：封装、继承、多态

面向过程

面向对象

类与对象的关系

创建与初始化对象

构造器

创建对象内存分析

总结：类与对象

封装

继承

多态

抽象类

接口

公告