类加载的执行顺序以及OOP面向对象三大特性

---

前言

关键字static以及面向对象的三大特性：封装、继承和多态。

---

一、static

1.static变量

---1.使用static修饰的成员变量，为类变量，属于类。
---2.在类加载时就被初始化
---3.生命周期和类一致
---4.可以通过类名.变量名调用

2.static方法

---1.在static方法中，不可以直接访问非static的变量和方法
---2.可以通过类名.方法名进行调用
---3.不可以访问this

3.static代码块

	局部代码块	成员代码块	static代码块
位置	方法中	类中	类中
数量	多个	多个	多个
执行顺序	依次执行	依次执行	依次执行
执行时间	-	每次创建对象时	第一次类加载时，只执行一次

代码示例：

public class Test {
    public static void main(String[] args) {
        Person p =new Person();
        p.showName();
        Person p2 =new Person();
    }
}
class Person{
    // 成员变量
    static String firstName;
    String lastName ;
    // 成员方法
    public void showName(){
        System.out.println(firstName+lastName);
    }
    public Person (){
        System.out.println("无参构造方法");
    }
    public Person(String lastName){
        System.out.println("有参构造方法");
        this.lastName=lastName;
    }
    // 代码块 代码块不能被调用,代码块是在指定的环节自动执行的
    {
        System.out.println("普通代码块");
        lastName="小明";
    }
    static{
        System.out.println("静态代码块");
        firstName="李";
    }
}

4.static优缺点

---优点：不需要实例化，静态变量的值可以直接重新赋值，静态方法可以通过类名.方法名调用
---缺点：初始化加载到内存，如果后续没被引用，很占用内存空间

二、封装性

1.定义

---封装就是把对象的属性和操作结合为一个独立的整体，并尽可能隐藏对象的内部的实现细节，仅仅对外公开使用的接口/方法 

2.特点

---1.提高代码复用性
---2.提高代码安全性
---3.高内聚，低耦合：封装细节便于维护，简化外部调用。

3.封装示例

public class Student {

	//1属性私有化
	//使用private访问修饰符修饰成员变量
	//2提供公有的外界访问的get、set方法 
    //boolean变量的get方法是is开头!
    private String name;
  
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void showInfo(){
        System.out.println("姓名:"+name);
    }
    
}

三、继承性

1.定义

---extends：字面意思是扩展 ，子类是父类的扩展，实现代码的重用。

2.要点

---1.Java中只有单继承
---2.如果一个类中没有调用extends，则它的父类是java.lang.Object
---3.子类继承父类，可以得到父类的全部属性和方法，但是不一定可以访问

3.继承示例

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("小明");
        student.rest();
        student.study();
    }
}

//父类
class	Person{
    private String name;
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void rest(){
        System.out.println(name+"睡觉");
    }
    public Person(){}

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

//子类
class	Student extends Person{

    public Student() {
    }

    public Student(String name) {
        super(name);
    }

    public void study(){
        System.out.println("学习");
    }
}

3.方法重写

---1.发生在子类和父类中间
---2.方法名相同、修饰符大于等于父类方法、返回值等于、参数相同、抛出的异常要小于等于父类。
---3.可以添加@override注解，检测是否重写
---4.父类中final修饰的方法不能被重写

//子类，延用上面的例子，对子类做出一下修改
class	Student extends Person{

    public Student() {
    }

    public Student(String name) {
        super(name);
    }
	//重写父类中的rest()方法
	public void rest(){
        System.out.println("子类重写睡觉");
    }

    public void study(){
        System.out.println("学习");
    }
}

4.权限修饰符

---private：表示私有，只有自己类可以访问
---default(friendly)：没有修饰符，只有同包的类能访问
---protected：可以被同包中的类以及其他包中的子类访问
---public：公开的，该项目所有包中的所有类都可以访问

修饰符	同一个类	同一个包（同包可继承）	子类	所有包所有类
private	√	-	-	-
默认/default	√	√	-	-
protected	√	√	√	-
public	√	√	√	√

四、多态性

1.定义

---多态指的是同一个方法调用，由于对象的不同可能会有不同的行为

2.要点

---1.多态是方法的多态，不是属性的多态，与属性无关
---2.三个必要条件：a.继承关系 b.方法重写 c.父类引用指向子类对象
---开闭原则OCP：对扩展开放，对修改关闭

多态示例：

class Action{
    public void eat(){
        System.out.println("吃米饭");
    }
}

class P1 extends Action{
    public void eat(){
        System.out.println("吃面条");
    }
    public void drink(){
        System.out.println("喝汽水");
    }
}
class P2 extends Action{
    public void eat() {
        System.out.println("吃汉堡");
    }
}

3.向上转型

---定义：将子类对象赋给父类引用;
---Fu fu = new Zi();

4.向下转型

---定义：将父类的引用变量转换为子类类型
---需要强制转换：Zi zi = (Zi)fu;
---需要用 fu instanceof Zi 判断在继承树上是否有上下级关系（避免ClassCastException）

5.抽象方法和抽象类

a.概念

---抽象方法：使用abstract修饰的方法，没有方法体，只有声明，是一种“规范”
---抽象类：使用abstract修饰的类，通过abstract方法定义规范，子类必须具体实现。

b.要点

---1.有抽象方法的类只能定义成抽象类
---2.抽象类不能实例化，不能new
---3.抽象类必须有构造方法，创建子类对象时候用
---4.子类必须实现父类的抽象方法

//定义抽象类、抽象方法
abstract class Play {
    public abstract void games();
}
//子类继承实现抽象方法
class Student extends Play {
	public void games() {
		System.out.println("玩游戏");
	}
}

---

总结

每天都在学习Java的道路上不断奔波，加油Java人。