day09构造方法&static&工具类的创建

构造方法

构造方法作用概述:

给对象的数据进行初始化

构造方法格式:

方法名与类名相同

没有返回值类型，连void都没有

没有具体的返回值

构造方法注意事项:

如果你不提供构造方法，系统会给出默认构造方法

如果你提供了构造方法，系统将不再提供

构造方法也是可以重载的

给成员变量赋值的两种方式：
    1、无参构造方法+setXxx(...)
    2、带参构造方法赋值

        一个标准类的3.0版本写法：
            成员变量：被private修饰
            构造方法：一个无参构造方法/一个带所有参数的构造方法
            成员方法：getXxx()和setXxx(...)
            show()：打印所有成员变量的值

package com.shujia.wyh.day09;
class Teacher {
    private String name;
    private int age;

    //构造方法：
    Teacher() {
    }

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

    //getXxx()
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    //setXxx(...)
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //show()
    public void show() {
        System.out.println(name + "---" + age);
    }
}

public class TeacherDemo {
    public static void main(String[] args) {
        //使用无参构造方法创建对象，使用setXxx() 对成员变量进行赋值
        Teacher t1 = new Teacher();
        t1.setName("小王");
        t1.setAge(18);
        t1.show();

        //使用带参数的构造方法创建对象并给成员变量进行赋值
        Teacher t2 = new Teacher("小杨", 18);
        t2.show();
    }
}

生成构造方法，get,set方法的快捷键
alt + Insert

        成员方法：
            根据返回值：
                1、没有返回值。void
                2、有返回值
            形式参数：
                1、没有参数的方法
                2、带参数的方法

package com.shujia.wyh.day09;
class Function {
    //定义一个没有返回值没有参数的成员方法
    public void fun1() {
        System.out.println("这是一个没有返回值，没有参数的方法");
    }

    //定义一个没有返回值，带参数的方法
    public void fun2(String name) {
        System.out.println("这是带参数无返回值的方法：" + name);
    }

    //定义有返回值没有参数的方法
    public String fun3() {
        return "你好";
    }

    //定义一个有返回值有参数的方法
    public String fun4(String s) {
        return s + "你好";
    }


}


public class FunctionDemo {
    public static void main(String[] args) {
        //创建Function类的对象
        Function function = new Function();
        //没有返回值的方法，直接调用可以输出结果
        function.fun1();
        function.fun2("hello");

        //有返回值的方法，调用的时候，需要用一个变量接收返回值或者直接使用
        String s1 = function.fun3();
        System.out.println(s1);
        String s2 = function.fun4("小明");
        System.out.println(s2);


    }
}

static

static关键字的特点：它可以修饰成员变量和成员方法
        1、随着类的加载而加载
        2、优先于对象而存在的。
        3、被类的所有对象共享：
        什么时候使用静态static关键字呢？
                如果某个成员变量是被所有的对象共享的，值是一样的，那么它就应该被定义为static静态的。
        4、可以通过类名直接调用

 

static关键字使用注意事项：
1、在静态方法中是没有this关键字的
        this代表的是当前调用该方法的对象，而被static修饰的成员是优先于对象而存在的。被static修饰的成员是随着类的加载而加载，这时候，还没有对象产生，也就说明没有this关键字，所以在静态方法中无法使用this关键字。
2、将成员方法分成两类：
                静态的成员方法：
                    访问的内容：
                        成员变量：只能访问静态的成员变量
                        成员方法：只能访问静态的成员方法
                非静态的成员方法：
                    访问的内容：
                        成员变量：既可以访问非静态的成员变量，也可以访问静态的成员变量
                        成员方法：既可以访问非静态的成员方法，也可以访问静态的成员方法

               总结：
                    静态的只能访问静态的。

package com.shujia.wyh.day09;
class Student3 {
    private String name;
    private int age;
    private static int a;

    public Student3() {
    }

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

    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;
    }

    public static void fun1(){
        //尝试访问非静态的成员变量name
        //无法从静态上下文中引用非静态变量 name
        //静态的成员方法不能访问非静态的成员变量
//        System.out.println(name);

        //尝试访问静态的成员变量a
        //静态的成员方法可以访问静态成员变量
        System.out.println(a);

        //尝试访问非静态的成员方法show()
        //无法从静态上下文中引用非静态方法 show()
        //静态的成员方法不能访问非静态的成员方法
//        show();

        //尝试方法静态的成员方法function()
        //静态的成员方法可以访问静态的成员方法
        function();

    }

    public void fun2(){
        //尝试访问非静态的成员变量name
        //非静态的成员方法可以访问非静态的成员变量
        System.out.println(name);

        //尝试访问静态的成员变量a
        //非静态的成员方法可以访问静态成员变量
        System.out.println(a);

        //尝试访问非静态的成员方法show()
        //非静态的成员方法可以方法非静态的成员方法
        show();

        //尝试方法静态的成员方法function()
        //非静态的成员方法可以访问静态的成员方法
        function();

    }

    public static void function(){

    }

    public void show() {
        System.out.println(name + "---" + age);
    }
}

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

    }
}

     静态变量与成员变量的区别：
        所属不同
            静态变量属于类，所以也称为为类变量
            成员变量属于对象，所以也称为实例变量(对象变量)
        内存中位置不同
            静态变量存储于方法区的静态区
            成员变量存储于堆内存
        内存出现时间不同
            静态变量随着类的加载而加载，随着类的消失而消失
            成员变量随着对象的创建而存在，随着对象的消失而消失
        调用不同
            静态变量可以通过类名调用，也可以通过对象调用
            成员变量只能通过对象名调用
    

工具类的创建：
        a：构造方法私有化，保证调用时不能创建对象

        b：方法被static修饰，可以通过类名直接调用，main方法是静态的，而静态的只能访问静态的，保证方法能被调用       

        c：用 类名.方法名 来调用

package com.shujia.wyh.day09;

/**
 * 这是针对数组相关操作的工具类
 * @author Alen
 * @version V.1.0
 *
 */
public class ArrayTool {
    /**
     * 这是私有的无参构造方法
     */
    private ArrayTool(){

    }


    /**
     * 这是遍历数组的方法，遍历后的格式是[元素1,元素2,元素3...]
     * @param array 这是调用该方法时需要传入的参数，数据类型是int类型的数组
     */
    public static void printArray(int[] array){
        for(int i=0;i<array.length;i++){
            if(i==array.length-1){
                System.out.print(array[i]+"]");
            }else if(i==0){
                System.out.print("["+array[i]+",");
            }else {
                System.out.print(array[i]+",");
            }
        }
        System.out.println();
    }

    /**
     * 这是数组逆序的方法
     * @param array 这是调用该方法时需要传入的参数，传入的数据类型是int类型的数组
     * @return 返回逆序后的数组
     */
    public static int[] niXu(int[] array){
        for(int start=0,end=array.length-1;start<=end;start++,end--){
            int temp = array[start];
            array[start] = array[end];
            array[end] = temp;
        }
        return array;
    }
}