第六章面向对象（下）

6.1 关键字：static

package atguigu.com;
/*
 * static关键字的使用
 * 
 * 1.static：静态的
 * 2.static可以用来修饰：属性、方法、代码块、内部类
 * 
 * 3.使用static修饰属性：静态变量（或类变量）
 *         3.1属性：按是否使用static修饰，又分为：静态属性和非静态属性（实例变量）
 *             实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类种的非静态属性。当修改其中一个对象
 *                     的非静态属性时，不会导致其他对象中同样的属性值的修改。
 *             静态变量：多个对象共享同一个静态变量。当通过某一个对象去修改静态变量时，会导致其他对象调用
 *                     此静态变量时，是修改过了的。
 *         3.2 static修饰属性的其他说明：
 *             ①静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
 *             ②静态变量的加载要早于对象的创建。
 *             ③由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中。
 *             
 *             ④            类变量        实例变量(非静态属性)
 *             类            yes            no
 *             对象            yes            yes
 * 
 *         3.3 静态属性举例：System.out;Math.PI;
 * 
 * 4.使用static修饰方法：静态方法
 *         ①随着类的加载而加载，可以通过"类.静态方法"去调用
 *         ②              静态方法        非静态方法
 *             类            yes            no
 *             对象            yes            yes
 *         ③ 静态方法中，只能调用静态的方法或属性
 *             非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
 * 
 * 5.static注意点：
 *     5.1在静态的方法内，不能使用this关键字，super关键字
 *     5.2关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
 * 
 * 6.开发中如何确定一个属性是否要声明为static?
 *         >属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
 *         >类中的常量也常常声明为static
 *         
 *     开发中如何确定一个方法是否要声明为static?
 *         >操作静态属性的方法，通常设置为static的
 *         >工具类的方法，习惯上声明为static的，比如：Math、Arrays、Collections
 * 
 */
public class StaticTest {
    public static void main(String[] args) {
        Chinese c1 = new Chinese();
        c1.name = "姚明";
        c1.age = 40;


        Chinese c2 = new Chinese();
        c2.name = "马龙";
        c2.age = 35;

        c1.nation = "CHN";
        System.out.println(c2.nation);

    }
}

//中国人
class Chinese{
    String name;
    int age;
    static String nation;



}

单例设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构，编程风格，以及解决问题的思考方式。
优点：由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

饿汉式

package atguigu2.com;
/*
 * 单例设计模式：
 * 1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例
 * 
 * 2.如何实现？
 * 饿汉式VS懒汉式
 * 
 * 3.区分饿汉式和懒汉式
 *     饿汉式：坏处：对象加载时间过长
 *             好处：线程安全
 *     懒汉式：好处：延迟对象的创建
 *             目前的写法坏处：线程不安全----->到多线程内容时，再修改
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 */
public class SingletonTest1 {
    public static void main(String[] args) {
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1 == bank2);
    }
}
//饿汉式:先造好对象
class Bank{

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

    }
    //2.内部创建类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

懒汉式

package atguigu2.com;
/*
 * 单例模式的懒汉式实现
 * 懒汉式：什么时候需要对象，什么时候造
 * 
 */
public class SingletonTest2 {
    public static void main(String[] args) {
        Order order1 = Order.getInstence();
        Order order2 = Order.getInstence();
        System.out.println(order1 == order2);
    }
}

class Order{

    //1.私有化类的构造器
    private Order(){

    }
    //2.先声明当前类对象，没有初始化
    //4.此对象也必须声明为static的
    private static Order instance = null;

    //3.声明public、static的返回当前类对象的方法
    public static Order getInstence(){
        if(instance == null){
            instance = new Order();
        }

        return instance;
    }
}

6.2理解main方法的语法

package atguigu2.com;
/*
 * main()方法的使用说明
 * 1.main()方法作为程序的入口
 * 2.main()方法也是一个普通的静态方法
 * 3.main()方法也可以作为我们与控制台交互的方式。（之前，使用Scanner）
 * 
 */
public class MainTest {
    public static void main(String[] args) {//入口
        Main.main(new String[100]);

        show();
    }

    public static void show(){

    }
}


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 atguigu2.com;

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

            for(int i = 0;i < args.length;i++){
                System.out.println("******" + args[i]);
                int num = Integer.parseInt(args[i]);
                System.out.println("###########" + num);

            }

        }    
}

6.3类的成员之四：代码块

package atguigu2.com;
/*
 * 类的成员之四：代码块（或初始化块）
 * 
 * 1.代码块的作用：用来初始化类，对象
 * 2.代码块如果有修饰的话，只能使用static
 * 3.分类：静态代码块 VS 非静态代码块
 * 4.静态代码块
 *         >内部可以有输出语句
 *         >随着类的加载而执行,而且只执行一次
 *         >作用：初始化类的信息
 *         >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
 *         >静态代码块的执行要优先于非静态代码块的执行
 *         >静态代码块内只能调用静态属性或静态方法
 * 5.非静态代码块
 *         >内部可以有输出语句
 *         >随着对象的创建而执行
 *         >每创建一个对象，就执行一次非静态代码块
 *         >作用:可以在创建对象时，对对象的属性等进行初始化
 *         >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
 *         >非静态代码块内可以调用静态的属性，静态的方法或非静态的属性，非静态的方法
 *     对属性可以赋值的位置：
 * ①默认初始化
 * ②显式初始化
 * ③构造器中初始化
 * ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式进行赋值
 * ⑤在代码块中赋值
 */
public class BlockTest {
    public static void main(String[] args) {
        String desc = Person.desc;
        Person.info();
        Person p1 = new Person();
        Person p2 = new Person();
        System.out.println(p1.age);
        Person.info();
    }
}


class Person{
    //属性
    String name;
    int age;
    static String desc = "我是一个人";
    //构造器
    public Person(){


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

    //静态代码块
    static{
        System.out.println("hello,static block");
        desc = "我是一个爱学习的人";
    }
    //非静态代码块
    {
        System.out.println("hello,block");
        age = 1;
    }

    //方法
    public void eat(){
        System.out.println("吃饭");

    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    public static void info(){
        System.out.println("是一个快乐的人");
    }
}