JAVA面向对象03

一·Static关键字

1. 使用staic关键字修饰的成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关。

2. static关键字修饰的成员可以使用引用.的方式访问，但推荐类名.的方式。

二·使用方式

1. 在非静态成员方法中既能访问非静态的成员又能访问静态成员。

   （成员：成员变量+成员方法，静态成员被所有对象共享共享）

2. 在静态成员方法中只能访问静态成员不能访问非静态成员。

   (成员：成员变量 + 成员方法， 因为此时可能还没有创建对象)

3. 在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用

   static关键字修饰。(不能滥用static关键字)

三·构造块和静态代码块

1. 构造块在类体中直接使用{}括起来的代码块。

2. 每创建一个对象都会执行一次构造块。

3. 静态代码块：使用static关键字修饰的构造块。

4. 静态类的代码块，随着类的加载时执行一次。

 

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

 

四·单例设计模式：

　　在某些特殊场合中，一个类对外提供且只提供一个对象时，这样的类叫做单例类，而设计单例的流程和思想叫做单例设计模式。

　　单例模式的实现流程

1. 私有化构造方法

2. 声明本类类型的引用指向本类类型的对象，使用private static关键字共同修饰

3. 提供公有的get方法，负责将对象返回出去，并使用public static关键字共同修饰。

　　

public class Singleton {
    
    // 2.声明本类类型的引用指向本类类型的对象，使用private static关键字共同修饰
    //private static Singleton sin = new Singleton();  // 饿汉式
    private static Singleton sin = null;               // 懒汉式
    
    // 1.私有化构造方法，使用private关键字修饰
    private Singleton() {}
    
    // 3.提供公有的get方法负责将对象返回出去，使用public static关键字共同修饰
    public static Singleton getInstance() {
        //return sin;
        if(null == sin) {
            sin = new Singleton();
        }
        return sin;
    }
}

public class SingletonTest {
    
    public static void main(String[] args) {
        
        // 1.声明Singleton类型的引用指向该类型的对象
        //Singleton s1 = new Singleton();
        //Singleton s2 = new Singleton();
        //System.out.println(s1 == s2); // 比较变量s1的数值是否与变量s2的数值相等  false
        //Singleton.sin = null;  可以使得引用变量无效
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // true
    }
}

五·继承

1. 当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类中已有的特征和行为而在多个类型只需要编写出自己独有的特征和行为机制，叫做继承。

2. java语言中使用extends关键字来表示继承。

3. 继承的特点：子类不能继承父类的构造方法和私有方法，但是私有的成员变量可以被继承，只是不能直接访问。

4. 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码super（）的效果。

5. 使用继承必须满足逻辑关系 子类 is a 父类，也就是不能滥用继承。

6. java语言只支持单继承不支持多继承。

 

六·方法重写

1. 从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写 一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做 方法的重写（Override）。

2. 要求方法名相同，参数列表相同以及返回值类型相同，从java5开始允许返回子类类型。

3. 要求方法的访问权限不能变小，可以相同或者变大。

4. 不能抛出更大的异常。

七·继承

当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类中已有的特征和行为而在多个类型只需要编写出自己独有的特征和行为机制，叫做继承。

 

public class Person {
    
    // 1.私有化成员变量，使用private关键字修饰
    private String name;
    private int age;
    //private boolean gender; // 性别
    
    // 3.在构造方法中调用set方法进行合理值的判断
    public Person() {
        System.out.println("Person()");
    }
    public Person(String name, int age) {
        System.out.println("Person(String, int)");
        setName(name);
        setAge(age);
    }
    
    // 2.提供公有的get和set方法并在方法体中进行合理值的判断
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age > 0 && age < 150) {
            this.age = age;
        } else {
            System.out.println("年龄不合理哦！！！");
        }
    }
    
    // 自定义成员方法实现特征的打印
    public void show() {
        System.out.println("我是" + getName() + "，今年" + getAge() + "岁了！");
    }
    // 自定义成员方法描述吃饭的行为
    public void eat(String food) {
        System.out.println(food + "真好吃！");
    }
    // 自定义成员方法描述娱乐的行为
    public void play(String game) {
        System.out.println(game + "真好玩！");
    }
}

 

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); // 表示调用父类的有参构造方法
        System.out.println("Worker(String, int, int)");
        //setName(name);
        //setAge(age);
        setSalary(salary);
    }
    
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        if(salary >= 2200) {
            this.salary = salary;
        } else {
            System.out.println("薪水不合理哦！！！");
        }
    }
    
    // 自定义成员方法描述工作的行为
    public void work() {
        System.out.println("今天的砖头有点烫手...");
    }
    // 自定义show方法覆盖从父类中继承的版本
    @Override  // 标注/注解，用于说明下面的方法是对父类方法的重写，若没有构成重写则编译报错
    public void show() {
        super.show(); // 表示调用父类的show方法
        System.out.println("我的薪水是：" + getSalary());
    }
}

public class Teacher extends Person {   
    
}

public class WorkerTest {
    
    public static void main(String[] args) {
        
        // 1.使用无参方式构造Worker类型的对象并打印特征
        Worker w1 = new Worker();
        // 当子类重写show方法后，则下面调用的是重写以后的版本
        w1.show(); // null  0
        
        System.out.println("----------------------------------");
        // 2.使用有参方式构造Worker类型的对象并打印特征
        Worker w2 = new Worker("zhangfei", 30, 3000);
        w2.show(); // zhangfei ...
        // 调用成员方法测试
        w2.eat("豆芽");
        w2.play("王者荣耀");
        w2.work();
    }
}

public class TeacherTest {
    
    public static void main(String[] args) {
        
        // 1.使用无参方式构造Teacher类型的对象并打印特征
        Teacher t1 = new Teacher();
        t1.show(); // null 0
    }
}

 

八·访问控制

常见的访问控制符

本类 同一包的类 子类 其他类

public 可以 可以 可以 可以

protected 可以 可以 可以 不可以

默认 可以 可以 不可以 不可以

private 可以 不可以 不可以 不可以

public 修饰的成员可以在任意位置使用

private 修饰的成员只能在本类中使用

通常情况下，成员方法都使用public 关键字修饰，成员变量都使用private关键字修饰。

　九·final关键字

1. final本意为最终的 不可改变的，可以修饰类，成员方法以及成员变量。

2. final关键字修饰类体现在该类不能被继承 表示防止滥用继承。

3. final修饰成员方法体现在该方法不能被重写但可以被继承。

4. final关键字修饰成员变量体现在该变量必须初始化且不能改变。

5. 常量：public static final 命名规范 所有字母大写 不同英文用_隔开。

//声明final修饰变量的三种方式
public class FinalMemberTest {
//    private final int cnt = 1; // 显式初始化
    private final int cnt;

    /*{
        cnt = 2;  // 构造块中进行初始化
    }*/

    public FinalMemberTest() {
        cnt = 3; // 构造方法体中进行初始化
    }

    public static void main(String[] args) {

        // 声明FinalMemberTest类型的引用指向该类的对象
        FinalMemberTest fmt = new FinalMemberTest();
        // 打印成员变量的数值
        System.out.println("fmt.cnt = " + fmt.cnt); // 0  1  2  3
    }
}