Java 学习 day06

01-面向对象(Static关键字)

package myFirstCode;

/*
静态：static。
用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，
还可以直接被类名调用。类名.静态成员。

static特点：
1，随着类的加载二加载。
2，优先于的对象存在
3，被所有对象所共享
4，可以直接被类名所调用

实例变量和类变量的区别：
1，存放位置。
    类变量随着类的加载而存在于方法区中。
    实例变量随着对象的建立而存在于堆内存中。
2，生命周期：
    类变量生命周期最长，随着类的消失而消失。
    实例变量生命周期随着对象的消失而消失。
    
静态有利有弊：
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
    可以直接被类名调用。
弊端：生命周期过长。
    访问出现局限性。（静态虽好，只能访问静态）
    
*/

class StaticDemo {

    class Person
    {
        String name;//成员变量，实例变量。
        static String country = "CN";//静态的成员变量，类变量。
        public static void show()
        {
            System.out.println("::::");
            this.haha();
        }
        public void haha()
        {}
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person.show();
    }

}

02-面向对象(main函数)

package myFirstCode;

/*
public static void main(String[] args)

主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。

主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
(String[] arr):函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

主函数是固定格式的：jvm识别。

jvm在调用主函数时，传入的是new String[0];
*/

class MainDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] arr = {"haha","hehe","heihei"};
        MainTest.main(arr);
    }

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

03-面向对象(静态什么时候使用)

package myFirstCode;

/*
什么时候使用静态？
要从两方面下手：
因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量（类变量）呢？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。

什么时候定义静态函数呢？
当功能内部没有访问到非静态数据（对象的特有数据），
那么该功能可以定义成静态的。
 */

public class Person1 {
    
    
        String name;
        public static void show()
        {
            System.out.println("haha");
        }
    
}
class Person2{
    public static void main(String[] args) 
    {
        //Person p = new Person();
        //p.show();
        Person1.show();

    }

}

04-面向对象(静态的应用-工具类)

package myFirstCode;

/*
静态的应用。
每一个应用程序中都有共性的功能。
可以将这些功能进行抽取，独立封装。
以便复用。

虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。
发现了问题：
1. 对象是用于封装数据的，可是ArrayTool对象并未封装特有数据；
2. 操作数组的每一个方法都没有用到ArrayTool对象中的特有数据；

这时就考虑，让程序更严谨，是不需要对象的。
可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。

将方法都静态后，可以方便用于使用，但是该类还是可以被其他程序建立对象的。
为了更为严谨，强制让该类不能简历对象。
可以通过将构造函数私有化完成。

private ArrayTool（）  --  私有化
*/

class ArrayTool
{
    private ArrayTool(){};  //私有化
    public static int getMax(int[] arr)
    {
        int max = 0;
        for (int x = 1; x < arr.length; x++) 
        {
            if (arr[x]>arr[max])
                max =x ;        
        }
        return arr[max];
    }
    public static int getMin(int[] arr)
    {
        int min = 0;
        for (int x = 1; x < arr.length; x++) 
        {
            if (arr[x]<arr[min])
                min =x ;
        }
        return arr[min];
    }
    
}

package myFirstCode;

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

        int[] arr = {3,6,98,65,5};
//        ArrayTool tool = new ArrayTool();
        
        
        int max = ArrayTool.getMax(arr);
        System.out.println("Max = " + max);
    }

}

05-面向对象(帮助文档的制作javadoc)

package myFirstCode;

/*
静态的应用。
每一个应用程序中都有共性的功能。
可以将这些功能进行抽取，独立封装。
以便复用。

虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。
发现了问题：
1. 对象是用于封装数据的，可是ArrayTool对象并未封装特有数据；
2. 操作数组的每一个方法都没有用到ArrayTool对象中的特有数据；

这时就考虑，让程序更严谨，是不需要对象的。
可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。

将方法都静态后，可以方便用于使用，但是该类还是可以被其他程序建立对象的。
为了更为严谨，强制让该类不能简历对象。
可以通过将构造函数私有化完成。

private ArrayTool（）  --  私有化
*/

/*
这是一个可以对数组进行操作的工具类，该类中提供了，获取最值等功能。
@author xuliang
@version V1.1
*/
class ArrayTool
{
    
    /*
    空参数构造函数。
     */
    private ArrayTool(){};  //私有化
    
    /*
    获取一个整型数组中的最大值。
    @param arr 接收一个int类型的数组。
    @return 会返回一个该数组中的最大值。
     */
    public static int getMax(int[] arr)
    {
        int max = 0;
        for (int x = 1; x < arr.length; x++) 
        {
            if (arr[x]>arr[max])
                max =x ;        
        }
        return arr[max];
    }
    
    /*
    获取一个整型数组中的最小值。
    @param arr 接收一个int类型的数组。
    @return 会返回一个该数组中的最小值。
     */
    public static int getMin(int[] arr)
    {
        int min = 0;
        for (int x = 1; x < arr.length; x++) 
        {
            if (arr[x]<arr[min])
                min =x ;
        }
        return arr[min];
    }
    
    
    /*
    给int数组进行选择排序。
    @param arr接收一个int类型的数组。
     */
    public void selectSort(int[] arr)
    {
        for (int x = 0; x < arr.length-1; x++) 
        {
            for (int y = x+1; y < arr.length; y++)
            {
                if (arr[x]>arr[y])
                {
                    swap(arr,x,y);
                    
                }
                
            }
            
        }
    }

    
    /*
    给数组中元素进行位置的置换。
    @param arr 接收一个int类型的数组。
    @param a 要置换的位置
    @param b 要置换的位置
     */
    private void swap(int[] arr, int a , int b) 
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
        
    }
    
}

/*
一个类中默认会有一个空参数的构造函数，
这个默认的构造函数的权限所属类一致。
如果类被public修饰，那么默认的构造函数也带public修饰符。
如果类没有被public修饰，那么默认的构造函数，也没有public修饰。
 */

06-面向对象(静态代码块)

package myFirstCode;

/*
静态代码块
格式：
static
{
    静态代码块中的执行语句。
}

特点：随着类的加载而执行，只执行一次，并优先于主函数。
用于给类进行初始化的。
*/


class StaticCode
{
    static
    {
        System.out.println("a");
    }
}

public class StaticCodeDemo 
{
    static
    {
        System.out.println("b");
    }

    public static void main(String[] args) 
    {
        new StaticCode();
        new StaticCode();
        System.out.println("over");
        

    }
    static
    {
        System.out.println("c");
    }

}

07-面向对象(对象的初始化过程)

package myFirstCode;


class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public void setAge(int a)
    {
        if(a>0 && a<130)
        {
            age = a;
            speak();
        }
        else
            System.out.println("false age");
    }
    
    public int getAge()
    {
        return age;
    }
    
    
    void speak()
    {
        System.out.println("age = "+age);
    }
}


//public class personDemo {
//
//    public static void main(String[] args) {
//        // TODO Auto-generated method stub
//        Person p = new Person();
//        p.setAge(25);
//    }
//
//}


public class personDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person p = new Person("zhangsan",20);
    }

}


/*
Person p = new Person("zhangsan",20);

该句话都做了什么事情？
1. 因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。
2. 执行该类中的static代码块，如果有的话，给person.class类进行初始化。
3. 在堆内存中开辟空间，分配内存地址。
4. 在堆内存中简历对象的特有属性。并进行默认初始化。
5. 对属性进行显示初始化。
6. 对对象进行构造代码块初始化。
7. 对对象进行对应的构造函数初始化。
8. 将内存地址付给栈内存中的p变量。

 */

08-面向对象(对象调用成员过程)

09-面向对象(单例设计模式)

package myFirstCode;

/*
设计模式：解决某一类问题最行之有效的方法。
Java中23种设计模式：
单例设计模式：解决一个类在内存只存在一个对象。

想要保证对象唯一。
1. 为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。
2. 还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。
3. 为了方便其他程序对自定义的访问，可以对外提供一些访问方式。

这三步怎么用代码体现呢？
1. 将构造函数私有化
2. 在类中创建一个本类对象。
3. 提供一个方法可以获取到该对象。


对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

 */

class Single
{
    private Single(){}
    private static Single s = new Single();
    public static Single getInstance()
    {
        return s;
    }
    
}

public class SingleDemo {


    public static void main(String[] args) 
    {
//        Single ss = Single.getInstance();

    }

}

class Student
{
    private int age;
    
    private static Student s = new Student();
    private Student(){};
    public static Student getStudent()
    {
        return s;
    }
    
    public void setAge(int age)
    {
        this.age = age;
        
    }
    public int getAge()
    {
        return age;
    }
}

10-面向对象(单例设计模式方式二)

package myFirstCode;


/*
这个是先初始化对象。
称为：饿汉式。

//class Single
//{
//    private static Single s  =  new Single();
//    private Single(){};
//    public static Single getInstance()
//    {
//        return s;
//    }
//}
*/

//对象是方法被调用时，才初始化，也叫作对象的延时加载。称为：懒汉式。**不常用，面试时候用
class Single
{
    private static Single s = null;
    private Single(){};
    public static Single getInstance()
    {
        if (s==null)
            s = new Single();
        return s ;
    }
}



public class SingleDemo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}