Java(十一)

知识点1：static关键字的使用

• 理解

 * 1. static:静态的
 * 2. static可以用来修饰的结构有：属性、方法、代码块、内部类

1. static修饰属性

 /* 3. static修饰属性：静态属性、静态变量
 *   3.1 创建了类的多个对象，每个对象拥有一套非静态的属性。意味着：当修改一个对象的非静态属性时，不会影响
 *   其他对象此属性的值。
 *   3.2 创建了类的多个对象，每个对象共享类中声明的静态的属性。意味着：当通过对象修改静态属性时，会影响
 *  其他对象对此属性的调用的值。
 *  3.3 类中声明的静态的属性，在内存中只有一份。
 *  3.4 类中声明的静态的属性，存放在方法区的静态域中。
 *  3.5 类中声明的静态的属性，随着类的加载而加载。
 *  3.6             静态属性（或静态变量、类变量）         非静态属性（或实例变量）
 *     类              yes                                       no
 *     对象             yes                                      yes
 */

2. static修饰方法

/* 4. static修饰方法：静态方法
 *   4.1 静态方法，随着类的加载而加载。
 *   4.2             静态方法         非静态方法
 *       类              yes            no
 *      对象             yes            yes
 *   4.3在静态方法内，可以调用当前类的静态结构：属性、方法。不能调用非静态的属性、方法
 *   非静态方法内，可以调用非静态的属性、方法。也可以调用静态的属性、方法
 *
 */

• 应用举例

 /*5. 应用：属性：Math.PI。
 *         方法：Math.random() / Math.sqrt() / Math.round() /
 *              Arrays.sort() / Arrays.binarySearch() /
 *
 *  6. 哪些情况下属性需要使用static修饰?
 *  *         > 类的多个对象中此属性的值是否相同，是否需要共享此属性
 *  *         > 类中定义的常量。
 *  *
 *  *     哪些情况下方法需要使用static修饰?
 *  *         > 调用静态属性的方法，通常声明为静态的
 *  *         > 工具类中的方法
 */

• 代码演示：

public class StaticTest {
    public static void main(String[] args) {
//        System.out.println(Chinese.name);
        System.out.println(Chinese.nation);
        Chinese c1 = new Chinese();
        c1.name = "陈";
        c1.age = 40;
        c1.nation = "中国";


        Chinese c2 = new Chinese();
        c2.name = "姚明";
        c2.age = 35;
        c2.nation = "CHN";

        System.out.println(c1);
        System.out.println(c2);

//        System.out.println(Chinese.name);
        System.out.println(Chinese.nation);

        Chinese.show();
        c1.show();
        c1.eat("米饭");
//        Chinese.eat("面条");//编译不通过

        //main()内可以直接调用静态的方法
        methodA();
    }

    public static void methodA(){
        System.out.println("A");
    }
}

class Chinese{

    String name;
    int age;

    static String nation;//国籍

    public Chinese(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Chinese() {
    }

    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 "Chinese{" +
//                "name='" + name + '\'' +
//                ", age=" + age +
//                '}';
//    }


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

    public static void show(){
        System.out.println("我是一个中国人");
        //在静态方法内，不能调用非静态的属性、方法
//        eat("米饭");
//        System.out.println(name);
        //在静态方法内，可以调用当前类的静态结构：属性、方法。
        System.out.println(nation);
        method();
    }

    public static void method(){

    }
    public void method1(){}

    public void eat(String food){
        //非静态方法内，可以调用非静态的属性、方法
        System.out.println(name + "喜欢吃：" + food);
        method1();
        //非静态方法内，可以调用静态的属性、方法
        System.out.println(nation);
        method();


    }

    public static String getNation() {
        return nation;
    }

    public static void setNation(String nation) {
        Chinese.nation = nation;
    }
}

3. 应用举例

• 举例1：

package com.atguigu.java;

/**
 *
 * static的应用举例
 */
public class CircleTest {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        Circle c2 = new Circle(3.3);
        Circle c3 = new Circle(3.5);

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);

        System.out.println("创建的Circle对象的个数为：" + Circle.getTotal());
    }
}

class Circle{
    private double radius;

    private int id;//自动生成id

    private static int init = 1001;//初始化id的因子

    private static int total = init;//记录创建的Circle对象的个数

    public Circle(){
        this.id = init++;
        total++;
    }

    public Circle(double radius){
        this();
        this.radius = radius;
    }

    @Override
    public String toString() {
        return "Circle{" +
                "radius=" + radius +
                ", id=" + id +
                '}';
    }

    public int getId() {
        return id;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public static int getTotal(){
        return total;
    }
}

• 举例2：

package com.atguigu.exer;

/**
 *
 * 编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、“利率”、“最小余额”，
 * 定义封装这些属性的方法。账号要自动生成。
 * 编写主类，使用银行账户类，输入、输出3个储户的上述信息。
 * 考虑：哪些属性可以设计成static属性。
 */
public class AcountTest {
    public static void main(String[] args) {
        Account account1 = new Account();
        Account account2 = new Account("123456",1000);

        System.out.println(account1);
        System.out.println(account2);

        Account.setAnnualInterestRate(0.018);
        Account.setMinBalance(1);
    }
}

class Account{
    private int id;
    private String password = "000000";
    private double balance;//余额
    private static double annualInterestRate;//年利率
    private static double minBalance;//最小余额
    private static int init = 1001;//自动生成id的因子

    public Account(){
        id = init++;
    }

    public Account(String password,double balance){
        //id = init++;
        this();
        this.password = password;
        this.balance = balance;
    }

    public int getId() {
        return id;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public static double getAnnualInterestRate() {
        return annualInterestRate;
    }

    public static void setAnnualInterestRate(double annualInterestRate) {
        Account.annualInterestRate = annualInterestRate;
    }

    public static double getMinBalance() {
        return minBalance;
    }

    public static void setMinBalance(double minBalance) {
        Account.minBalance = minBalance;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", password='" + password + '\'' +
                ", balance=" + balance +
                '}';
    }
}

4. 设计模式与单例模式

• 设计模式

 * 是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模免去我们自己再思考和摸索。
 * 就像是经典的棋谱，不同的棋局，我们用不同的棋谱。
 *
 * 经典的设计模式有：23种
创建型模式，共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 
结构型模式，共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 
行为型模式，共11种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 

• 单例模式

 * 二、单例模式(或单子模式、Singleton)
 *   保证在整个的软件系统中，对某个类只能存在一个对象实例
 *
 * 三、实现方式：① 饿汉式  ② 懒汉式
 *
 *   对比：懒汉式好：延迟对象的创建，节省内存空间。线程是不安全的。
 *        饿汉式好：线程是安全的。

• 饿汉式

public class SingletonTest {
    public static void main(String[] args) {
//        Bank b1 = new Bank();
//        Bank b2 = new Bank();

        Bank bank = Bank.getBank();
        Bank bank1 = Bank.getBank();

        System.out.println(bank == bank1);
    }
}

//饿汉式
class Bank{

    //1. 构造器私有化
    private Bank(){

    }

    //2. 声明并创建当前类的唯一实例，声明为private的
    //4. 必须将此唯一的实例声明为static的
    private static Bank bank = new Bank();

    //3. 通过方法返回当前类的唯一实例
    public static Bank getBank(){
        return bank;
    }

}

• 懒汉式

package com.atguigu.java1;

/**
 */
public class SingletonTest1 {
    public static void main(String[] args) {
        ChairMan c1 = ChairMan.getInstance();
        ChairMan c2 = ChairMan.getInstance();
        System.out.println(c1 == c2);
    }
}

//懒汉式
class ChairMan{

    //1.构造器私有化
    private ChairMan(){

    }

    //2.声明当前类的唯一实例，声明为private的
    //4. 必须将此唯一的实例声明为static的
    private static ChairMan chairMan = null;

    //3. 通过方法返回当前类的唯一实例
    public static ChairMan getInstance(){

        if(chairMan == null){

            chairMan = new ChairMan();
        }
        return chairMan;
    }
}

知识点2：main()的理解

/**
 *
 * main()的理解
 * 1. main()是程序的入口
 * 2. main()是一个静态的方法，形参为String[]类型
 * 3. 我们可以使用main()从键盘读取数据，只不过数据的类型只能是String。
 *     具体使用，比如：java MainDemo Tom 123 "Jerry"
 */
public class MainTest {
    public static void main(String[] args) {
//        System.out.println("hello");

        Main.main(new String[20]);
    }
}

class Main{
    public static void main(String[] args) {
        for(int i = 0;i < args.length;i++){
            args[i] = "args_" + i;
            System.out.println(args[i]);
        }
    }
}

• 举例如何从键盘获取数据

package com.atguigu.java1;

public class MainDemo {
    public static void main(String[] args) {

        for(int i = 0;i < args.length;i++){
            System.out.println("元素" + i +"为：" + args[i]);
        }

    }
}

知识点3：类的成员之四：代码块

package com.atguigu.java2;

/**
 *
 * 类的成员之四：代码块
 *
 * 1. 代码块只能使用static修饰。
 *    分类：静态代码块  vs  非静态代码块
 *
 *
 * 2. 静态代码块：
 *      > 内部可以声明执行语句
 *      > 随着类的加载而执行
 *      > 由于类的加载只加载一次，所以静态代码块只执行一次。
 *      > 静态代码块的执行要早于非静态代码块的执行。
 *      > 作用：用于初始化类的信息：静态变量
 *      > 如果多个静态代码块，则按照声明的先后顺序执行
 *      > 静态代码块内，只能调动当前类的静态结构
 *
 * 3. 非静态代码块：
 *      > 内部可以声明执行语句
 *      > 随着对象的创建而执行。即：每创建一个对象，都执行一次非静态代码块
 *      > 作用：用于初始化对象的信息：实例变量
 *      > 如果多个非静态代码块，则按照声明的先后顺序执行
 *      > 非静态代码块内，可以调动当前类的静态结构和非静态结构：属性、方法
 *
 */
public class BlockTest {
    public static void main(String[] args) {

        System.out.println(Person.info);

        Person p1 = new Person();
        Person p2 = new Person();
    }
}

class Person{
    String name;
    int age;

    static String info;

    //非静态代码块
    {
        System.out.println("我是非静态代码块2");
    }
    {
        System.out.println("我是非静态代码块1");
        int num = 10;
        age = 1;
        eat();
    }




    //静态代码块
    static{
        System.out.println("我是静态代码块2");
    }
    static{
        System.out.println("我是静态代码块1");
        int num = 10;
        info = "我是人";
//        eat();

        show();
    }

    public static void show(){}

    public void eat(){
        System.out.println("人吃饭");
        sleep();
    }

    public void sleep(){
        System.out.println("人睡觉");
    }

    public Person(){}

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

• 属性赋值的位置及先后顺序

package com.atguigu.java2;

import java.net.SocketTimeoutException;

/**
 *
 * 1. 属性可以被赋值的位置：
 * ① 默认初始化
 * ② 显式初始化
 * ③ 构造器中初始化
 *
 * ④ 创建了对象以后，通过"对象.属性" 或 "对象.方法"的方式，进行赋值
 *
 * ⑤ 代码块中赋值
 *
 * 2. 赋值的先后顺序：
 *  ① - ② / ⑤ - ③ - ④
 *
 *  说明: ② 和 ⑤ 执行的先后顺序取决于声明的先后顺序。
 */
public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();
        System.out.println(order.orderId);

        Order order1 = new Order(3);
        System.out.println(order1.orderId);
    }
}

class Order{

    {
        orderId = 1;
    }

    int orderId = 2;

    public Order(){}

    public Order(int orderId){
        this.orderId = orderId;

    }


}