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

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

  封装、继承、多态

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

在java中类的定义语法：

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

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

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

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

对象创建的详细过程：

  1. class Person{
  2.         private String name;
  3.         private int age;
  5.         public Person{
  6.             this.name=name;
  7.             this.age=age;
  8.         }
  9.         {
  10.             age=20;
  11.         }
  12.     }
  1. class Main{
  2.         public static void main(String[] args){
  3.             Person person=new Person("XXX",18);
  4.         }
  5.     }

对象的具体创建过程：
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区分局部变量和成员变量
封装的含义：定义类的过程

继承：

为什么要有继承？

正面角度：拓展父类

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

继承语法：


 

  1.     public class 子类名 extends 父类名{
  3.     }

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

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修饰变量：变量变常量

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

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

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


 

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

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

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

抽象类的构造方法作用：

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

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

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

使用接口：

  1. class ClassName implement InterfaceName{
  2.             重写接口中的方法
  3.         }

多态：

向上转型和向下转型

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

父类引用指向子类的对象

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

  1. class Person{
  2.         String name;
  4.         public void info(){
  6.         }
  7.     }
  9.     class Chinese extends Person{
  10.         @override
  11.         public void info(){
  13.         }
  14.     }
  16.     class Main{
  17.         public static void main(String[] args){
  18.             Person chinese=new Chinese();多态
  19.         }
  20.     }

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

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

例:

  1. class Animal{
  3.     class Cat{
  5.     }
  6.     class Dog{
  8.     }
  9.     class Main{
  10.             public static void main(String[] args){
  11.                 Animal animal=new Animal();
  12.                 Cat cat=(Cat)animal;
  13.                 Dog dog=(Dog)animal；//错误
  15.                 Animal01 animal01=new Dog();
  16.                 Dog dog=(Dog)animal01;//正确
  17.             }
  18.         }

补充：

instanceof:

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

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

版权声明：本文为Floating-dream原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/Floating-dream/p/14882609.html