【学习】面向对象

一. 面向对象思想介绍

面向过程：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的。（C语言）

面向对象：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能。（Java，C++，Python）

 

类与对象

类是对象的描述  对象是类的实体。

• 前提 :  Java中想要创建对象, 必须要先有类的存在
• 类 :  是一组相关属性和行为的集合,  将其看做为是对象的设计图
• 对象 : 根据类(设计图)创建出来的实体.
• 关系 :

    依赖关系 :  需要根据类创建对象

    数量关系 :  一对多的关系,  根据一个类创建出多个对象

对象内存图

单个对象内存图

 

两个对象内存图

两个引用指向相同内存图 

 

成员变量和局部变量的区别

 

 

this关键字

this关键字的作用：可以调用本类的成员(变量, 方法)解决局部变量和成员变量的重名问题

this可以解决的问题

• 问题：在一个类中，如果成员变量和局部变量重名了，那么在使用的时候，会使用谁？

• • Java 会根据就近原则优先使用局部变量

• 问题：非要使用成员变量怎么办？

• • 可以使用 this 关键字进行区分

• 总结：

        this 可以调用本类的成员（成员变量，成员方法）

        使用 this 可以区分出成员变量和局部变量的重名问题.

 this本质

this 代表当前类对象的引用（地址）

public class Student {
    public void print(){
        System.out.println("打印this关键字----------------" + this);
    }
}


public class Demo3This {
    public static void main(String[] args) {
        Student stu1 = new Student();
        System.out.println("打印stu1对象名----------------" + stu1);
        stu1.print();

        Student stu2 = new Student();
        System.out.println("打印stu2对象名----------------" + stu2);
        stu2.print();
    }
}


打印stu1对象名----------------com.itheima.mthis.Student@7b23ec81
打印this关键字----------------com.itheima.mthis.Student@7b23ec81
打印stu2对象名----------------com.itheima.mthis.Student@6acbcfc0
打印this关键字----------------com.itheima.mthis.Student@6acbcfc0

this内存图解

 

构造方法

构造方法介绍

构建、创造对象的时候，所调用的方法

 

构造方法格式

1.方法名与类名相同，大小写也要一致

2.没有返回值类型，连void都没有

3.没有具体的返回值（不能由return带回结果数据）

构造方法执行时机

1.创建对象的时候调用，每创建一次对象，就会执行一次构造方法

2.不能手动调用构造方法

构造方法的作用

1.本质作用：创建对象

2.结合构造方法执行时机：给对象中的属性（成员变量）进行初始化

构造方法内存图解

构造方法也是方法，在执行的时候，也会进入栈内存

 

二、面向对象三大特性

三大特性之封装

封装介绍

隐藏实现细节，仅对外暴露公共的访问方式

封装在代码中的常见体现：

将属性抽取到类当中，这是对数据的一种封装

将代码抽取到方法中，这是对代码功能的一种封装

私有成员变量，提供setXxx和getXxx方法

封装的好处：

1、提高了代码的安全性

2、提高了代码的复用性

private 关键字

是一个权限修饰符

可以修饰成员（成员变量和成员方法）

被private修饰的成员只能在本类中才能访问

针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

• 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
• 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
• 权限修饰符，权限修饰符可用来修饰成员
• • private
  • (defalut)
  • protected
  • public

• 被 private 修饰的成员，只能在本类中进行访问

 标准 JavaBean 编写

● 成员变量使用 private 修饰
● 构造方法
        ○提供一个无参构造方法【推荐必需】
        ○提供一个带参的构造方法【建议要有】
● 成员方法
        ○提供每一个成员变量对应的 setXxx() / getXxx()

三大特性之继承

把多个类中的共同属性和方法提取出来，定义成一个类；由关键字extends来实现父子关系，除了不能继承父类中private，final 修饰的【属性】或者【方法】还有【构造方法】，其他都能继承并且能调用：

注意：

• 当父类中与子类中属性或者方法同名时候的调用格式：this和super。
• 当父类中的方法不满足子类要求时候，还可以重写方法。
• 父类中非私有的成员变量、方法

继承体系

支持单继承，不能多继承。

但可以多层继承：A->extends B ->extends C   A间接继承了C

所有的类默认直接或间接继承于Object类

子类访问父类构造方法

子类创建对象的特点
⚫ 特点：子类对象创建时， 默认先执行父类的无参构造方法。
⚫ 原理：在子类的所有构造方法的第一行，默认有super()，表示调用父类的无参构造方法。

如果父类中没有无参构造器，会出现什么现象呢？
⚫ 会报错。因为子类默认是调用父类无参构造器的。

public class Person {
    private String name;
    private int age;


    public Person() {
    }

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

public class Teacher extends Person{
    private String salary;


    public Teacher() {
        super(); //默认隐藏
    }

    public Teacher(String name, int age, String salary) {
        super(name, age); //父类有参构造器
        this.salary = salary; //子类有this初始化
    }
}

super 与 this

super关键字是在子类对象内部指代其父类空间的引用

super：指定的是父类中的内存，代之父类对象。

• 需要注意：必须放到首位（第一行）
• 常在父类和子类同名的时候使用（方法名或者是变量名）
• 在子类的构造方法中，内存会默认调用super（）——调用父类的无参构造

this：代指这个对象；

 

方法重写

在子类中创建一个父类一模一样的方法，覆盖掉父类的方法

使用场景：如果子类觉得父类的方法不够满足自己的需求，就重写

重写的方法是非私有的

条件

• 必须有继承关系
• 一般与父类的方法格式保持一致，只能改写方法体【推荐】
• @Overwrited为格式检查注解
• 权限关系：必须大于父类。
• 返回值类型：比父类小或等
• 私有方法和静态方法不能被重写。 还有final

 

三大特性之多态

概念

多态是同一个行为具有多种不同表现形式。属性不具有多态性。

基于继承\实现的一种现象，一定要有方法重写

在Java中的体现形式是：
⚫ 父类的引用指向子类的对象。
⚫ 接口的引用指向实现类的对象。

Printer p1 = new ColorPrinter();

printer为父类，ColorPrinter为子类。

多态的前提

有继承/实现关系

有方法重写

有父类引用指向子类对象

多态访问成员访问特点

方法的调用 ：

父类中必须有同名的方法，否则会报错。（方法重写）

左边看编译，右边看运行。Animal a =new Dog （ ）；

多态的表现方式

对象多态 ： 父类\接口 对象名 = new 子类();

行为多态 ：方法重写之后，调用子类的方法

注：属性是没有多态

我们平时指的多态一般是行为多态

多态的优缺点

多态优点：

1.解耦【方案的切换】
2.提高代码的扩展性。
定义方法时，如果将父类 或 接口 作为参数，在调用方法
时，可以传递任意子类对象极大提高方法的通用性。

多态缺点:——由instanceof关键字解决
多态下不能使用子类的特有功能。

多态的类型转换

package com.itheima02多态的特点和类型转换;

/*
    多态的缺点：
        在多态下，无法访问子类特有的成员。
    解决办法：
        使用强制类型转换
                Animal a = new Dog();
                Dog dog = (Dog) a;
        解决类型转换异常：使用 instanceof 判断类型
 */
public class Test02 {
    public static void main(String[] args) { 
        //自动类型转换 【向上转型】
        Animal a = new Dog();

        //强制类型转换（向下转型）
        //可能有类型转换异常 ClassCastException
        //在强转前，做类型的判断
        /*
            对象名 instanceof  类名
                判断 对象   
        */
        if(a instanceof Dog){
            Dog dog = (Dog) a; //强转
            dog.lookHome();
        }else {
            System.out.println("当前类型不是Dog"); 
        }

    }
}