​

活动地址：CSDN21天学习挑战赛

目录

static静态关键字

static是什么，static修饰成员变量的用法

static修饰成员方法

static应用知识：工具类

static应用知识：代码块

static应用知识：单例

面向对象三大特征之二：继承

什么是继承

继承使用场景

继承的特点

继承后：成员变量、成员方法的访问特点

继承后：方法重写

继承后：子类构造器的特点

this和super详情

static静态关键字

static是什么，static修饰成员变量的用法

static是静态的意思，可以用来修饰成员变量、成员方法。

static修饰成员变量之后称为静态成员变量（类变量），修饰方法之后称为静态方法（类方法）。

static修饰后的成员变量，可以被类的所有对象共享（访问、修改)。

public class User {  
    static String name;  
    int age;
    }
​
public class Test {    
    public static void main(String[] args) {
    // 目标：认识static，掌握static修饰成员变量的特点和使用场景。
    // 1、访问的区别      
    System.out.println(User.name);   
    // System.out.println(User.age); // 报错      
    User u = new User();    
    System.out.println(u.age);      
    System.out.println(u.name);       
    // 静态成员变量可以用类，也可以用对象访问        
    // 实例成员变量只能用对象访问。        
    // 2、static修饰静态成员变量的特点。       
    User u1 = new User();        
    u1.age = 23;      
    u1.name = "李四";      
    User u2 = new User();       
    u2.age = 35；       
    u2.name = "张三";     
    System.out.println(u1.age); // 23        
    System.out.println(u1.name); // 传值教育   
    }
}
​
运行结果：
    null
    0
    null
    23 //李四的年龄，u1这个对象
    张三 //张三的名字，u1这个对象

内存：方法区里面肯定有（Test.class main方法 ，User.class）

栈内存就是 三个User的对象 u1、u2、u3

由于new了三个对象，所以需要在堆内存开辟空间。

对象里面的静态变量统一放在User类的静态变量区，非静态变量存放在3个不同的地址 中。对象在初始化的时候静态变量会被覆盖。

总结：

特点：

静态成员变量（有static修饰，属于类、加载一次，内存中只有一份），访问格式：

类名.静态成员变量(推荐) 对象.静态成员变量(不推荐)。

实例成员变量（无static修饰，属于对象），访问格式：

对象.实例成员变量。

使用场景：

静态成员变量：表示在线人数等需要被类的所有对象共享的信息时。

实例成员变量：属于每个对象，且每个对象的该信息不同时（如：name,age,money…）

static修饰成员方法

成员方法的分类：

静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问。

实例成员方法（无static修饰，归属于对象），只能用对象触发访问。

使用场景：

表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。

如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。

public class Student {
    private String name;  
    // 1. 实例方法: 无static修饰的，属于对象的
    public void study(){    
        System.out.println(name +  “在好好学习~~~”); 
    }
    // 2. 静态方法：有static修饰，属于类和对象共享的
    public static int getMax(int a , int b){    
        return a > b ? a : b; 
    }
    public static void main(String[] args) {    
        // 1. 类名.静态成员方法
        System.out.println(Student.getMax(10 , 2));     
        // 注意：同一个类中访问静态成员类名可以不写  
        System.out.println(getMax(2 , 10));         
        // 2. 对象.实例成员方法 
        // study(); // 会报错   
        Student s = new  Student();      
        s.name = "猪八戒";        
        s.study();       
        // 3. 对象.静态成员方法。（不推荐）   
        System.out.println(s.getMax(20 , 10));  
    }
}
​

内存：

方法区里面肯定有（Stydent.class main方法 getMax方法 study方法）

栈内存就是Stydent的对象 s

由于new了对象，所以需要在堆内存开辟空间。

堆空间里面，在s的指向的地址存放着属性name，和两静态方法，一个是实例方法。

注意：

使用static修饰的方法，可以被实例方法直接使用，也可以被静态方法直接使用。

但是实例方法不能再静态方法中直接使用。

静态方法中是不可以出现this关键字的。

static应用知识：工具类

什么是工具类

类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用的。

例如：验证码功能在程序里面经常使用，我们使用静态修饰，当我们需要使用时，直接调用即可。降低代码重复率。

使用工具类的好处

一是调用方便，二是提高了代码复用（一次编写，处处可用）

static应用知识：代码块

代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类），定义在类中方法外。

在Java类下，使用 { } 括起来的代码被称为代码块 。

静态代码块:

格式：static{}

特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次使用

场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

构造代码块（了解，见的少）：

格式：{}

特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行 前执行使用

场景：初始化实例资源。

用例：我们写程序在实现功能完善前，没有连接数据库，我们可以通过静态代码块进行伪造方法进行测试。以免破坏了数据库数据内容。

static应用知识：单例

什么是设计模式（Design pattern）

开发中经常遇到一些问题，一个问题通常有n种解法的，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。

设计模式有23种，对应23种软件开发中会遇到的问题。

单例模式

可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。

例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

懒汉式单例代码实现：

public class LazySingleton{
    private static volatile LazySingleton instance=null;//保证instance在所有     线程中同步
    private LazySingleton(){ } //private避免类在外部被实例化
    public static synchronized LazySingleton  getInstance(){//getInstance方      法前加同步
        if(instance==null){ instance=new LazySingleton(); }
        return instance;
    } 
}

饿汉式单例代码实现：

public class HungrySingleton{ 
    private static final HungrySingleton instance = new 
    HungrySingleton();
    private HungrySingleton(){ }
    public static HungrySingleton getInstance(){
        return instance;
    }
}

实现的原理：定义一个类，把构造器私有。然后我们将对象使用静态修饰变量存储一个对象。创建对象时，都会覆盖原来的。所以只会存在一个对象，然后返回存在的那个对象。

面向对象三大特征之二：继承

什么是继承

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。

代码格式 public class Student extends People {}

Student称为子类（派生类），People称为父类(基类 或超类)。

作用：当子类继承父类后，就可以直接使用父类的使用非私有变量和方法了

继承能提高代码的复用性

继承使用场景

一般情况下，一批类中，他们具有相同得属性变量，但是作用的方法不同。这个时候我们就可以使用继承。

例如：

父类是宠物类，所有的宠物（猫，狗）都有名字，年龄性别。但是他们的行为都不一样。父类中就可以写入他们公有的所有变量和行为方法。然后在不同的子类中然后进行重载，实现不同的行为方法。

内存：

当我们创建子类对象后，一个地址空间会生成两个空间，一个父类空间，一个子类空间，父类空间存放着父类定义的变量和方法，子类空间存放这个子类重新定义的变量和方法

继承的特点

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。

Java是单继承模式：一个类只能继承一个直接父类，但是可以实现多个接口。

Java不支持多继承、但是支持多层继承。

Java中所有的类都是Object类的子类。

子类不能继承父类的构造方法。

想要访问父类的私有属性，想要创建父类对象。

继承后：成员变量、成员方法的访问特点

在子类方法中访问成员（成员变量、成员方法）满足：

就近原则先子类局部范围找

然后子类成员范围找

然后父类成员范围找，如果父类范围还没有找到则报错。

在子类和父类存在相同名字的成员，会优先使用子类的，但是使用super关键字可以指定访问父类的。使用格式： super.父类的变量/方法

继承后：方法重写

什么是方法重写

在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

方法重写的应用场景

当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。子类可以重写父类中的方法。

@Override重写注解

@Override是放在重写后的方法上，作为重写是否正确的校验注解。

加上该注解后如果重写错误，编译阶段会出现错误提示。

建议重写方法都加@Override注解，代码安全，优雅！

方法重写注意事项和要求

重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。

私有方法不能被重写。

子类重写父类方法时，访问权限必须大于或者等于父类 （暂时了解 ：缺省 < protected < public）

子类不能重写父类的静态方法，如果重写会报错的。

继承后：子类构造器的特点

在子类初始化前都先进行父类初始化，如果父类没有初始化完成，子类无法使用父类数据。

子类调用父类构造器使用的是super()；所以子类构造器的第一行语句默认都是：super()；不写也存在。

this和super详情

this：代表本类对象的引用；super：代表父类存储空间的标识。

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量访问本类成员变量	this.成员方法(…)访问本类成员方法	this(…)访问本类构器
super	super.成员变量访问父类成员变量	super.成员方法(…)访问父类成员方	super(…)访问父类构造器