​
​

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

一、学习语法步骤

二、static静态关键字

1、static是什么？

• static是静态的意思，可以用来修饰成员变量、成员方法
• static修饰成员变量之后称为静态成员变量(类变量)，修饰成员方法之后称为静态方法(类方法)
• static修饰后的成员变量，可以被类的所有对象共享（访问、修改）

public class User {
    static String name; //静态成员变量
    int age; //实例成员变量
}

1
2
3
4
5

public class HelloWorld {
    public static void main(String[] args) {
        User user = new User();
        user.age = 30;
        user.name = "张老师";  //不推荐 对象.实例成员变量
        User.name = "李老师"; //静态变量可以直接被  类名.静态成员变量 使用  推荐此方法
//        User.age = 35;   //报错的

        User u1  = new User();
        u1.name = "张老师";

        User u2 = new User();
        u2.name = "李老师";


        System.out.println(u1.name);
        System.out.println(u2.name);   //static修饰  内存中只加载一次，只有一份 所以u1和u2的值是相同的
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

静态成员变量：表示在线人数等需要被类的所有对象共享信息时
实例成员变量：属于每个对象，每个对象信息不同时

static注意事项：

静态方法只能访问静态成员，不可以直接访问实例成员
实例方法可以访问静态成员，也可以访问实例成员
静态方法中不可以出现this关键字

三、static工具类

1、工具类优点

• 内部是静态方法，每个方法可以实现一种功能
• 方便调用，提高代码复用

2、工具类要求

• 推荐构造器私有化处理
• 工具类不需要创建对象

四、static代码块

定义：用{}括起来称为代码块

1、静态代码块

• 格式:

static{}
1

• 特点：需要static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
• 场景：类加载时初始化静态数据

2、构造代码块

• 格式：

{}
1

• 特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并在构造器执行前执行
• 场景：初始化实例资源

五、static单例模式

1、什么是设计模式(Design pattern)？

• 定义：一个问题N中解法，最优的解法被人们称之为设计模式，设计模式大概有20多种
• 学设计模式重点：
  1）这种模式用来解决什么问题
  2）遇到问题，该模式是怎么写的，如何解决这个问题

2、什么是单例模式？

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

1）饿汉单例实现步骤？

• 定义一个类，把构造器私有
• 定义一个静态变量存储一个对象

/**
 * 定义一个单例类
 */
public class Single {
    //定义一个静态变量存储一个对象：属于类，与类一次加载一次
    public static Single single = new Single();
    //单例必须有私有构造器
    private Single(){
        System.out.println("Single");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

2）懒汉单例实现步骤?

需要改对象时，才创建一个对象(延迟加载对象)

• 定义一个类，把构造器私有
• 顶一个静态变量存储一个对象
• 提供一个返回单例对象的方法

/**
 * 定义一个单例类
 */
class SingleInstance {
    //定义一个静态变量存储一个对象：属于类，与类一次加载一次
    public static SingleInstance single; //默认值null
    //单例必须有私有构造器
    private SingleInstance(){
        System.out.println("Single");
    }
    //必须有一个返回单例对象的方法
    public static SingleInstance getSingle() {
        return single;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

六、面向对象之继承

1、什么是继承？

用extend关键字，让一个类和另一个类建立成父子关系
Object称之为父类(基类或超类)，继承Object的称之为子类(派生类)
作用：当子类继承父类后，可以直接使用父类的公共属性和方法

好处：

可以提供代码复用性
继承格式：子类 extend 父类

public class SingleInstance extends Object{
    public static void main(String[] args) {
        System.out.println("SingleInstance是子类，Object是父类");
    }
}

1
2
3
4
5
6

2、继承设计规范

• 设计规范

子类相同特征(属性、方法)在父类中定义，子类特有属性和方法定义在自己的类中

public class Person {
    private String name;
    private int age;

    public void eat(){
        System.out.println("人天生就会吃");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class Teacher extends Person{
    private String ClassName;

    public void teacherCourse(){
        System.out.println("老师必须要会授课");
    }

    public String getClassName() {
        return ClassName;
    }

    public void setClassName(String className) {
        ClassName = className;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "ClassName='" + ClassName + '\'' +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class User {
    public static void main(String[] args) {
        Teacher tc = new Teacher();
        tc.setName("张老师");
        tc.setAge(35);
        tc.setClassName("数学课");
        System.out.println(tc.getName());
        System.out.println(tc.getAge());
        System.out.println(tc.getClassName());
        tc.teacherCourse();
        tc.eat();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

3、继承特点

• 子类可以继承父类的属性和方法，不能继承父类构造器
• Java是单继承模式：一个子类只能继承一个父类
• Java不支持多继承，支持多层继承，A继承B，C继承B
• Java所有类都是Object的子类
• 子类可以继承父类私有成员，但是不能直接访问

4、继承后成员变量和方法访问特点

• 就近原则：
  在子类方法中访问成员(成员变量、成员方法)

先子类局范围找
然后子类成员范围找
然后父类成员范围找，如果父类没有找到则报错

• 子父类中成员重名，子类优先，必须在父类找

用super关键字，指定访问父类成员
格式：super.父类成员变量/方法

5、方法重写

• 定义：

在继承中，子父类出现同命名方法声明，称子类此方法重写

• 场景

子类需要父类功能，父类该功能不能完全满足子类需求时

• @Override重写注解

@Override是放在方法重写上面作为校验
加上该注解，编译阶段有错误会提示
建议重写方法都加是@Override

• 注意事项和要求

重写方法名称、形参列表必须与被重写方法名称、形参列表一致
私有方法不能被重写
子类重写父类时，访问权限必须大于或者等于父类(缺省 子类不能重写父类静态方法，如重写会报错

6、子类构造器特点

• 特点

子类所有构造器默认都会优先访问父类中无参构造器，在访问自己

• 原因

子类初始化时，可能会用到父类的数据，如父类没有初始化完成，子类无法使用父类数据

• 调用父类构造器？

子类构造器第一句，super()默认

7、访问父类带参构造器

• super() 调用父类带参构造器

初始化继承自父类数据

• 父类没有无参构造器，只有有参构造器

子类构造器用super()，手动调用父类带参构造器 ----子类默认调用父类无参构造器

8、this,super使用

• this 本类对象引用
• super 父类存储空间标识
  

• 注意点：

子类通过this() 去调用本类其它构造器，本类其它构造器会通过super()手动调用父类构造器，最终调用父类构造器
this()、super()必须放在构造器第一行，二者不能同时出现在同一个构造器中