static 关键字修饰成员变量

• 类成员的概念

static关键字修饰成员方法

• 静态成员被所有成员所共享。

构造块和静态代码块

/*
    实现构造块和静态代码块的使用
*/
public class BlockTest {
    //当需要在执行构造方法体之前做一些准备工作时,则将准备工作的相关代码写在构造块中即可,比如对成员变量进行统一的初始化操作.
    {
        System.out.println("构造块1！");
    }
    {
        System.out.println("构造块2！");
    }
    //静态代码块会随着类的加载而准备就绪,会先于构造块执行
    //当需要执行代码块之前随着类的加载而做一些准备工作时,则编写代码到静态代码块中,比如:加载数据库的驱动包等
    static {
        System.out.println("============静态代码块！");
    }
    public BlockTest() {
        System.out.println("====构造方法体！");
    }
    public static void main(String[] args) {
        BlockTest bt = new BlockTest();
        BlockTest bt2 = new BlockTest();
    }
}

main方法的详解

/*
    编程实现main方法测试
*/
public class MainTest {
    public static void main(String[] args) {
        System.out.println("参数数组中元素的个数是:" + args.length);
        System.out.println("传递给main方法的实际参数是:");
        for(int i = 0; i < args.length; i++) {
            System.out.println("下标为" + i + "形参变量数值为:" + args[i]);
        }
    }
}

Singleton和SingletonTest类的框架实现

/*
    编程实现singleton类的封装
*/
public class Singleton {
    //2. 声明本类类型的引用指向本类类型的对象 private + static 
    private static Singleton sin = new Singleton();
    //1. 私有化构造方法
    private Singleton(){}
    //3. 提供公有的静态get方法将对象返回出去 public statc
    public static Singleton getInstance() {
        return sin;
    }
}

/*
    编程实现singleton类的测试
*/
public class SingletonTest {
    public static void main(String[] args) {
        //1. 声明Singleton类型的引用指向该类型的对象
        /*
        Singleton s1 = new Singleton();
        Singleton s2 = new Singleton();
        System.out.println(s1 == s2);
        */
        //Singleton.sin = null;
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }
}

单例设计模式

饿汉式与懒汉式的单例模式

/*
    编程实现singleton类的封装
*/
public class Singleton {
    //2. 声明本类类型的引用指向本类类型的对象
    //private static Singleton sin = new Singleton(); //饿汉式
    private static Singleton sin = null;            //懒汉式
    //1. 私有化构造方法
    private Singleton(){}
    //3. 提供公有的静态get方法将对象返回出去 public statc
    public static Singleton getInstance() {
        //return sin;
        if(null == sin) {
            sin = new Singleton(); 
        }
        return null;
    }
}

• 饿汉式在虚拟机加载时就会创建,懒汉式方法调用时才会创建对象

开发中推荐使用饿汉式, 考虑到多线程抢占进程资源**

继承

• 无论是使用何种方式构造子类对象时都会自动调用父类的无参构造方法，来初始化从符类中辑成的成员变量，相当于在构造方法第一行增加代码super()的效果。
• super() this()都必须在构造方法的第一行。

• 在使用继承时必须满足逻辑关系，子类is-a父类, 不能滥用继承
• Java语言中只支持单继承而不支持多继承

• 直接子类, 直接父类
• 间接子类, 间接父类

重写

• super. 调用父类的方法
• @Override

/*
    自定义worker类继承自Person类
*/
public class Worker extends Person {
    private int salary;
    public Worker() {
        super(); //表示调用父类的无参构造方法，若没有加编译器自动加
        System.out.println("Worker()");
    }
    public Worker(String name, int age, int salary) {
        super(name, age); //表示调用父类的无参构造方法
        //this();  错误: 对this的调用必须是构造器中的第一个语句
        System.out.println("Worker(String, int, int)");
        //setName(name);
        //setAge(age);
        setSalary(salary);
    }
    public int gerSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        if(salary >= 2200) {
            this.salary = salary;
        } else {
            System.out.println("Please check salary!");
        }
    }
    //自定义成员方法描述工作的行为
    public void work() {
        System.out.println("今天的砖头有点烫手！");
    }
    //自定义show方法覆盖从父类中继承的版本.
    @Override         //标注/注解, 用于说明下面的方法是对父类方法的重写,若没有重写则编译报错    【错误: 方法不会覆盖或实现超类型的方法】
    public void show() {
        super.show();   //表示调用父类show方法
        System.out.println("我的工资是:" + gerSalary());
    }
}

方法重写的相关原则

• 要求方法名相同、参数列表相同以及返回值类型相同，从Java5开始允许返回子类类型**。**

父类(Person)方法

Person show() {
}

子类(Worker)重新父类方法

Worker show() {
}

• 要求方法的访问权限不能变小，只能相同或者变大

子类继承父类的时候，可以看作是子类对父类的扩展，所以访问权限只能大于等于。

IDEA的使用

• alt+insert —> generate 生成

• Ctrl+alt+s 设置
• sout —> System.out.println();
• psvm —> public static void main(String[] ags)
• shift+enter 另起一行
• 无需Ctrl+s 自动保存
• Shift+F10
• Ctrl + d 复制行
• Ctrl+Shift+/ 多行的注释
• Shift+ / 单行的注释
• alt+shift+方向 移动当前行

构造块和静态代码块考点

package com.lagou.task08;
/**
 * @author 西风月
 * @date 2020/7/14
 * @description
 */
public class SuperTest {
    {
        System.out.println("SuperTest类中的构造块!"); //(2)
    }
    static {
        System.out.println("SuperTest类中的静态代码块!"); //(1)
    }
    public SuperTest() {
        System.out.println("SuperTest  类中的构造方法体!"); //(3)
    }
    public static void main(String[] args) {
        SuperTest st = new SuperTest();
    }
}

package com.lagou.task08;
/**
 * @author 西风月
 * @date 2020/7/14
 * @description
 */
public class SubSuperTest extends SuperTest {
    {
        System.out.println("===============SubSuperTest类中的构造块!"); //(2)
    }
    static {
        System.out.println("===============SubSuperTest类中的静态代码块!"); //(1)
    }
    public SubSuperTest() {
        System.out.println("===============SubSuperTest  类中的构造方法体!"); //(3)
    }
    public static void main(String[] args) {
        SubSuperTest sst = new SubSuperTest();
    }
}

权限修饰符和包的定义

Package

• 包就是目录概念

• 包的导入
• 自动编译
• 导入静态成员

import static 很少使用

final修饰类和方法的作用

• final 关键字修饰类体现在该类不能被继承
  • 主要用于防止滥用继承，如：java.lang.String

• 修饰方法表示不能被重写

• final修饰成员变量

常量的概念

总结

1. static关键字
   1. 概念 类层级,对象所共享,推荐使用类名的访问
   2. 使用方式
   3. 构造块和静态代码块
   4. 单例模式

首先私有化构造方法 private修饰
声明本类引用指向本类对象,用private static关键字修饰
提供公有的get方法 public static
饿汉式 推荐使用 多线程使用
懒汉式

1. 继承
   1. 概念
      1. extends
   2. 特点
      1. 构造/私有的方法不能继承 代码复用,提高可维护性和拓展性
      2. 会调用父类的无参构造方法 super()
      3. is-a的逻辑关系,不能滥用继承
      4. 特点: 单继承
   3. 方法的重写
      1. 重写的原则
         1. 要求方法名相同、参数列表相同以及返回值类型相同
         2. 访问权限不能变小,只能大于或等于
         3. 不能抛出更大的异常
2. 访问控制
   1. public protected 默认 private
   2. static
3. final关键字
   1. 修饰类表示该类不能被继承
   2. 修饰方法表示该方法不能被重写
   3. 修饰成员变量表示该成员变量必须初始化
      1. 显式的初始化
      2. 构造块初始化
      3. 构造方法初始化
   4. 常量的概念
      1. public final static 修饰