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()方法，获取当前对象的类型