Java面向对象中封装、继承、多态的学习总结

面向对象概念

所有操作基于对象进行操作实现

面向对象的三大特征

封装、继承、多态

类:具有相同特征和行为物体的统称

在java中类的定义语法:

[修饰符]   class   类名{
  属性;
  方法;
}

属性和方法称为成员、分别是成员属性和成员方法

类的使用:
1.创建对象
结合关键字new, new 对象名(参数列表);

2.调用它的方法和属性
对象名.属性
对象名.方法(参数列表)

对象创建的详细过程:

class Person{
        private String name;
        private int age;

        public Person{
            this.name=name;
            this.age=age;
        }
        {
            age=20;
        }
    }
class Main{
        public static void main(String[] args){
            Person person=new Person("XXX",18);
        }
    }

对象的具体创建过程:
1.在堆中开辟内存空间,JVM对象进行静态初始化,就是给各个属性赋予默认值

整数(byte、short、int、long):0

小数(double、float):0.0

字符(char):0/' '

布尔值(boolean):false



2.JVM对对象进行动态初始化,就是执行< init >()方法,注意:IDEA 2018版本才显示< init >()方法,其他版本不显示

< init >()方法组成:成员属性的赋值语句和构造代码块从上往下组成


例如:{

age=20;

}



3.构造方法初始化:利用构造方法对属性进行赋值

this:
出现的位置:出现在本类的构造方法中/成员方法中

作用:

1、表示当前对象,谁调用该方法,this就指代谁

2、可以调用本类中的构造方法,减少代码重复

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

1.作用域:方法中可以直接使用成员变量(成员变量作用范围整个类,局部变量只能在方法中访问)

2.内存分配:成员变量在堆中分配内存,局部变量在栈中分配内存

3.成员变量:直接定义在类中 局部变量:定义在方法中,包括方法参数

4.生命周期:局部变量在方法执行完成就销毁,成员变量根这个对象的销毁而销毁

5.有无默认值:JVM不会给局部变量赋予默认值,JVM会给成员变量赋予默认值

如果一个类中局部变量和成员变量同名,优先访问局部变量,可以用this区分局部变量和成员变量
封装的含义:定义类的过程

继承:

为什么要有继承?

正面角度:拓展父类

反面角度:将子类中相同的代码抽象到父类中,提高代码的复用性,减少重复代码

继承语法:


public class 子类名 extends 父类名{

    }

方法的重写:
子类重写父类中的方法,除了方法体重写之外,其他的和父类定义的一样
方法的重载:
在同一个类中,方法名相同,参数列表不同(类型,顺序,个数),和返回值相同

super:
1、可以在子类的构造方法中调用父类的构造方法,通过super调用父类中的构造方法
必须放在子类构造方法中的第一行,如果子类构造方法没有调用父类的构造方法,默认调用无参构造
2、调用父类的构造方法给父类中定义的属性赋值,或调用父类中的属性和方法

修饰符:
访问修饰符、static修饰符、final修饰符

访问修饰符的作用:控制被修饰的内容(类、类的成员)在其他类中的访问情况,具体参考baidu

一般结论:属性使用private,方法使用public

在开发中,我们需要给类中每个属性提供一个getter获取方法和setter修改方法

访问修饰符:public protected default private

static修饰符作用:控制被修饰的内容的加载时机

static修饰的成员就变为静态成员,而且静态成员不在属于单个对象,而是属于类

直接可以通过类名.属性/方法名直接调用

类的加载过程:

JAVA中的类都是懒加载,需要用的时候才去加载

具体过程:

1、JVM将class加载到方法区(元空间)

2、JVM对类进行静态初始化:给静态属性在方法区中的常量池开辟空间

3、JVM对类进行动态初始化:执行< cinit >()方法

< cinit >()方法组成:静态属性的赋值语句+静态代码块从上到下依次组成

类的初始化小细节:

如果父类没有初始化,首先加载父类的.class文件

然后再初始化本类

final修饰符:

final修饰类:类不可被继承

final修饰方法:方法不可被重写

final修饰变量:变量变常量

修饰成员变量,成员变量要再对象初始化阶段或构造方法中完成赋值

修饰静态变量:静态变量必须在类的初始化阶段完成赋值

抽象类:
抽象方法的定义语法:


public abstract class ClassName{
            public abstract 返回值类型 方法名(参数列表);

        }

抽象可以含有抽象方法,但不能被实例化

一般的普通类不可以含有抽象方法,但含有抽象方法的一定是抽象类

抽象类的构造方法作用:

给子类对象在初始化的时候给父类中定义的属性赋值

接口:比抽象类更加抽象,在接口中只能含有抽象方法(接口中方法的访问修饰符默认是public abstract)和常量
定义语法:

[访问修饰符] interface InterfaceName{
        public static final 数据类型 常量名=值;
        public abstract 返回值类型 方法名(参数列表);
    }

使用接口:

class ClassName implement InterfaceName{
            重写接口中的方法
        }

多态:

向上转型和向下转型

向上转型:父类类型/接口类型 对象名=子类类型的对象/子类类型对象的引用

父类引用指向子类的对象

通过对象名只能调用父类/接口中定义的方法,编译看左边,运行看右边

class Person{
        String name;

        public void info(){

        }
    }

    class Chinese extends Person{
        @override
        public void info(){

        }
    }

    class Main{
        public static void main(String[] args){
            Person chinese=new Chinese();多态
        }
    }

向下转型:
语法格式:子类类型 对象名=(子类类型)new 父类类型();

在编译的时候,始终是正确的
但在运行的时候,需要检测有边对象的真正类型,只有类型和声名类型一样才能强转成功

例:

class Animal{

    class Cat{

    }
    class Dog{

    }
    class Main{
            public static void main(String[] args){
                Animal animal=new Animal();
                Cat cat=(Cat)animal;
                Dog dog=(Dog)animal;//错误

                Animal01 animal01=new Dog();
                Dog dog=(Dog)animal01;//正确
            }
        }

补充:

instanceof:

A instanceof B: 判断对象A是否是B类或B的子类的实例化对象

getClass()方法,获取当前对象的类型