复习，静态函数，main方法的详解，单例设计模式

构造函数：

构造函数的作用：初始化对应的对象。

构造函数的格式：

修饰符函数名(形式参数){
函数体
}

构造函数要注意的事项：
1. 构造函数是没有返回值类型的。
2. 构造函数的函数名是必须与类名一致。
3. 构造函数不是由我们手动调用的，是我们在创建了对应的对象时，jvm会根据你创建的对象传递的参数调用
对应的对象。
4. 如果一个类没有显示写上一个构造函数的时候，那么java编译器会为该类添加一个无参的构造函数。
5. 如果一个类已经显示写上一个构造函数的时候,那么java编译器则不会再为该类添加一个无参的构造函数。
6. 构造函数是可以以函数重载的形式存在多个。

构造代码块：

构造代码块的作用：给对象进行统一的初始化。

构造代码块的格式：
{
代码；
}

构造代码块是在创建了代码块所属类的对象时调用一次。

this关键字：

this关键字代表了所属函数的调用者对象。

this关键字的作用：
1. 一个类中存在同名的成员变量与局部变量时，在方法的内部默认是访问局部变量的，可以通过this关键字指定访问成员变量的数据。
2. this关键字还可以在构造函数中调用另外一个构造函数初始化对象，

this关键字调用构造函数要注意的事项：
1. this关键字调用其他的构造函数时，必须要是在第一个语句。
2. this关键字调用构造函数时不能出现相互调用，因为是一个死循环。
3. 如果在方法的内部访问一个变量时，该变量只存在于成员变量中，局部没有没有，这时候java编译器会为该变量的前面添加this关键字。

static（静态、修饰符）

static修饰成员变量时：static修饰成员变量时,那么该成员变量的数据就是一个共享的数据.

静态成员变量的访问方式：

方式一：使用对象进行访问。
对象.属性名
方式二：可以使用类名进行访问。
类名.属性名
注意：
1. 非静态成员变量不能类名直接访问，只能使用对象进行访问。
2. 千万不要为了方便访问成员变量而使用static修饰，一定要是该数据是共享数据时才使用static修饰。

static（静态、修饰符）

static修饰方法（静态的成员方法）:

访问方式：

方式一：可以使用对象进行访问。
对象.静态的函数名();

方式二：可以使用类名进行访问。
类名.静态函数名字。

推荐使用是类名直接访问静态的成员。

静态的成员变量与非静态的成员变量的区别：
1. 作用上的区别：
1. 静态的成员变量的作用共享一个数据给所有的对象使用。
2. 非静态的成员变量的作用是描述一类事物的公共属性。
2. 数量与存储位置上的区别：
1. 静态成员变量是存储方法区内存中，而且只会存在一份数据。
2. 非静态的成员变量是存储在堆内存中，有n个对象就有n份数据。
3. 生命周期的区别：
1. 静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失。
2.非静态的成员数据是随着对象的创建而存在，随着对象被垃圾回收器回收而消失。

静态函数要注意的事项：
1. 静态函数是可以调用类名或者对象进行调用的，而非静态函数只能使用对象进行调用。
2. 静态的函数可以直接访问静态的成员，但是不能直接访问非静态的成员。
原因：静态函数是可以使用类名直接调用的，这时候可能还没有存在对象，
而非静态的成员数据是随着对象的存在而存在的。

3. 非静态的函数是可以直接访问静态与非静态的成员。
原因：非静态函数只能由对象调用，当对象存在的时候，静态数据老早就已经存在了，而非静态
数据也随着对象的创建而存在了。

4. 静态函数不能出现this或者super关键字。
原因：因为静态的函数是可以使用类名调用的，一旦使用类名调用这时候不存在对象，而this
关键字是代表了一个函数的调用者对象，这时候产生了冲突。

静态的数据的生命周期：静态的成员变量数据是优先于对象存在的。

static什么时候修饰一个函数？

如果一个函数没有直接访问到非静态的成员时，那么就可以使用static修饰了。一般用于工具类型的方法

静态函数不能访问非静态的成员？
静态函数只要存在有对象，那么也可以访问非静态的数据。只是不能直接访问而已。

静态数据的内存图：

代码演示：

class Student{

    String name; //名字

    static String country = "中国"; //国籍

    //静态代码块 ：静态代码块是在Student.class文件加载到内存的时候就马上执行的。
    static{
        System.out.println("静态代码块执行了...");
    }

    //构造函数
    public Student(String name){
        this.name = name;
    }

    //非静态的成员函数
    public  void study(){
        System.out.println("好好学习"+this);
    }


    //静态函数
    public static void sleep(){  //静态方法与非静态方法的字节码文件是同时存在内存中 的。 只是静态的成员变量数据是优先于对象存在而已。
        Student s= new Student("铁蛋");
        System.out.println(s.name+"呼呼大睡...");
    }
}


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

        Student.sleep();
        // Student s = new Student("狗娃");

    }
}
运行 结果：

需求：编写一个数组的工具类。
Arrays.toString（） [1,2,3,4];
sort()

代码演示：

class ArrayTool{

    public static String toString(int[] arr){
        String result="";
        for(int i=0;i            if(i==0){
                result="["+arr[i]+","+result;
            }else if(i==(arr.length-1)){
                result=arr[i]+"]";
            }else{
                result=arr[i]+","+result;

        }
    }
        return result;
}
    public static void sort(int[] arr){
        for(int i = 0; i < arr.length-1 ; i++){
            for(int j = i+1 ; j                if(arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

}



class Demo3
{
    public static void main(String[] args)
    {
        int[] arr = {12,1,456,165};
        ArrayTool tool = new ArrayTool();

        ArrayTool.sort(arr);
        String info = ArrayTool.toString(arr);
        System.out.println("数组的元素："+ info);
    }
}
运行结果：

main函数的详解：

public ：公共的。权限是最大，在任何情况下都可以访问。 private
原因：为了保证让jvm在任何情况下都可以访问到main方法。

static: 静态。静态可以让jvm调用main函数的时候更加的方便。不需要通过对象调用。

void: 没有返回值。因为返回的数据是给 jvm，而jvm使用这个数据是没有意义的。所以就不要了。

main: 函数名。注意： main并不是关键字,只不过是jvm能识别的一个特殊的函数名而已。

arguments ：担心某些程序在启动需要参数。

代码：

class Demo28 {

    public static  void main(String[] args)
    {
        System.out.println("数组的长度："+ args.length);
        for(int i = 0 ; i             System.out.print(args[i]+",");
        }
        
    }
}
结果：

单例设计模式：保证一个类在内存中只有一个对象。

单例数据模式的需求分析：

模式：模式就是解决一类问题的固定步骤。

模式的概念最早起源于建筑行业....

建房子的步骤都是一样子：

打地基-----> 浇柱子------->盖楼面--------->砌墙--------->封顶---->装修-----入住

软件行业中23种设计模式：

单例设计模式
模板设计模式
装饰者设计模式
观察者设计模式
工厂设计模式

单例设计模式的步骤：

饿汉单例设计模式
1. 私有化构造函数。
2. 声明本类的引用类型变量，并且使用该变量指向本类对象。
3. 提供一个公共静态的方法获取本类的对象。

懒汉单例设计模式：
1. 私有化构造函数。
2. 声明本类的引用类型变量，但是不要创建对象，
3. 提供公共静态的方法获取本类的对象，获取之前先判断是否已经创建了本类对象
，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，
然后再返回。

推荐使用：饿汉单例设计模式。因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一类在内存中只有一个对象。

代码演示：

//饿汉单例设计模式 ----> 保证Single在在内存中只有一个对象。
class Single{

    //声明本类的引用类型变量，并且使用该变量指向本类对象
    private static Single s = new Single();

    //私有化构造函数
    private Single(){}

    //提供一个公共静态的方法获取本类的对象
    public static  Single getInstance(){
        return s;
    }
}



//懒汉单例设计模式 ----> 保证Single在在内存中只有一个对象。

class Single2{

    //声明本类的引用类型变量，不创建本类的对象
    private static Single2 s;

    //私有化了构造函数
    private Single2(){}

    //
    public static Single2 getInstance(){
        if(s==null){
            s = new Single2();
        }
        return s;
    }
}

class Demo28
{
    public static void main(String[] args)
    {
        Single2 s1 = Single2.getInstance();
        Single2 s2 = Single2.getInstance();
        System.out.println("是同一个对象吗？"+ (s1==s2));

    }
}
运行结果：

复习，静态函数，main方法的详解，单例设计模式

相关

标签