day09（构造方法，给成员变量赋值，创建对象，static，工具类的创建）

一、构造方法：给成员变量做初始化作用的

1、构造方法可以发生重载

2、如果我们没有提供构造方法，系统会默认提供一个无参空方法体的构造方法

3、如果我们提供了构造方法，无论提供的是无参还是有参，系统都不会提供了

格式：方法名与类名一致，没有返回值类型，连return都没有，构造方法在创建对象的时候调用

 构造方法：

       语句定义格式：

            1、方法名与类名相同

            2、构造方法是没有返回值的，连void都没有

            3、没有具体的返回值

class Studnt{

    private String name;

    private int age;

    //定义一个构造方法

    Student(){

         System.out.println("这是一个构造方法");

    }

    public String getName(){

        return name;

    }

     public int getAge(){

         return age;

    }

}

public class StudentDemo1{

     public static void main(String[] args){

          //创建Student类的对象

         //调用的是无参构造方法创建对象

        Student s1 = new Student();

        Student s2 = new Student();

//          System.out.println("s1.getName()+"---"+s1.getAge());

     }

}

【】定义一个Demo，其中定义一个求两个数据和的方法，定义一个测试类Test，进行测试

class Demo{

    //方式1：虽然我们实现了两个数求和，但是值是固定的，没有灵活度

//    int a = 10;

//    int b = 20;

//    public int sum(){

//         return a+b;

//     }

     //方式2：

     public int sum(int a,int b){

          return a + b;

      }

      //方式3：使用面向对象的思想

//    private int a;

//    private int b;

//    Demo(int a,int b){

//        this.a = a;

//        this.b = b;

//      }

//      public int sum(){

//          return a + b;

//      }

//  这道题，最好的解决方式是方式2，为什么呢？

//  方式3虽然使用了面向对象的思想，但是我们忽略了一个问题

//  想一想，什么情况可以将一个变量作为成员变量呢？

//  当成员变量是该类的相关属性的时候，可以去定义成成员变量

//  这里的a，b仅仅表示的是一个方法中的两个参数，与我们Demo类没有关系

//所以不应该定义成成员变量

}

public class Test1{

    public static void main(String[] args){

        //创建对象调用方法

//       Demo demo = new Demo();

//       int sum = demo.sum();

//       System.out.println(sum);

         Demo demo = new Demo();

         int sum = demo.sum(10,20);

         System.out.println(sum);

//    方式3：

//       Demo demo = new Demo(100,200);

//       int sum = demo.sum();

//       System.out.println(sum);

     }

}

4、成员方法：

         根据返回值：

               1、没有返回值。void

               2、有返回值

          形式参数：

                1、没有参数的方法

                2、带参数的方法

class Function{

    //定义一个没有返回值没有参数的成员方法

    public void fun1(){

        System.out.println("这是带参数无返回值的方法："+ name);

    }

    //定义有返回值没有参数的方法

    public String fun3(){

        return "数加科技";

   }

  //定义一个有返回值有参数的方法

public String fun4(String s){

    renturn s + "你好";

  }

}

public class FunctionDemo{

    public static void main(String[] args){

         //创建Function类的对象

         Function function = new Function();

         //没有返回值的方法，直接调用可以输出结果

         function.fun1();

         function.fun2("15期");

         //有返回值的方法，调用的时候，需要用一个变量接收返回值或者直接使用

         String s1 = function.fun3();

         System.out.println(s1);

          String s2 = function.fun4("明旺");

          System.out.println(s2);

     }

}

二、给成员变量赋值的两种方式：

1、无参构造+setXxx(...)

class Cat{

    private String name = "小白";

    private int age = 3;

    private String kind = "英短";

    //生成构造方法，get，set方法的快捷键

    //alt + Insert

    public Cat(){

    }

    public Cat(String name,int age,String kind){

         this.name = name;

         this.age = age;

         this.kind = kind;

    }

public String getName(){

     return name;

}

public void setName(String name){

     this.anme = name;

}

public int getAge(){

      return age;

}

public void setAge(int age){

     this.age = age;

}

public String getKind(){

     return kind;

}

public void setKind(String kind){

     this.kind = kind;

}

  public void show(){

     System.out.println(name+ "---"+age+"---"+kind);

  }

}

public class CatDemo{

     public static void main(String[] args){

         Cat cat = new Cat();

         cat.show();

      }

}

2、带参构造赋值

问题：我们之前在类中从来没有写过构造方法，但是我们依旧可以创建对象，请问用的是那里的构造方法呢？

注意：

1、如果我们没有给出构造方法，JVM会自动提供一个无参空方法体的构造方法

2、如果我们给出了一个构造方法还会提供吗？

      如果我们提供了一个构造方法，系统就不会再提供默认的无参空方法体的构造方法

3、构造方法可以发生重载

给成员变量赋值的方式：

      1、使用setXxx()的方式给私有成员变量赋值

      2、使用带参数的构造方法给私有的成员变量赋值，这里需要与this关键字配合使用

     类的组成：成员变量，成员方法

     今天我们又学习了一个新的成员：构造方法

     一个标准类的3.0版本写法：

          成员变量：被private修饰

          构造方法：一个无参构造方法/一个带所有参数的构造方法

          成员方法：getXxx()和setXxx()

          show()：打印所有成员变量的值

          无论我们提供的是带参构造还是无参构造，只要我们自己提供了一个，系统永远就不会提供了

class Teacher {

    private String name;

    private int age;

    //构造方法：

    Teacher(){

    }

    Teacher(String name,int age){

        this.name = name;

        this.age = age;

    }

    //getXxx()

    public String getName(){

        renturn 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){

         //使用无参构造方法创建对象，使用getXxx()对成员变量进行赋值

        //开发使用这种方法

        Teacher t1 = new Teacher();

        t1.setName("小王");

        t1.setAge(18);

        t1.show();

        //使用带参数的构造方法创建对象并给成员变量进行赋值

        //上课使用这种方法

        Teacher t2 = new Teacher("小杨",18);

        t2.show();

    }

}

3、构造方法可以发生重载

class Construction1{

     privateString name;

     private int age;

    Construction1(){

        System.out.println("这是我们自己提供的一个无参构造方法");

     }

     Construction1(String name){

        System.out.println("这是我们提供的带参数name的构造方法");

        this.name = name;

    }

   Construction1(String age){

        System.out.println("这是我们提供的带参数age的构造方法");

        this.age = age;

     }

     Construction1(String name,int age){

         System.out.println("这是我们提供的两个带参数name,age的构造方法");

         this.name = name;

         this.age = age;

      }

      public void show(){

          System.out.println(name+"---"+age);

      }

}

public class ConstructionDemo1{

    public static void main(String[] args){

//      Construction1 construction1 = new Construction1();

//      construction1.show();

//     使用带参数的构造方法来创建对象

//      Construction1 c2 = new Construction1("周家祥");

//       c2.show();

//       Construction1 c3 = new Construction1(18);

//        c3.show();

//       使用带两个参数name，age的构造方法来创建对象

         Construction1 c4 = new Construction1("姚龙",18);

         c4.show();

     }

}

三、创建对象初始化的流程

     a:先将class文件加载到方法区中

     b:在栈中为变量开辟空间

     c:在堆内存中创建对象

     d:系统给成员变量进行默认赋值

     e：给成员变量进行显示赋值

     f：构造方法给成员方法进行赋值

     g：将堆内存中的地址赋值给栈内存中的变量

main方法的格式讲解：

   public static void main(String[] args){}

   public:公共的，访问权限是最大的，因为main是由jvm调用的，所以权限要足够大

   static：静态的，不需要创建对象，通过类名直接调用，方便jvm访问

   void：表示无返回值，因为我们直接说过返回值，是返回给调用者的，而调用main方法是由jvm调用的，返回值给他没有意义

String[] args:参数是一个字符串数组，数组形参名叫args？

这个东西怎么样？如何传参？值去哪里？

早期JDK1.5之前，没有Scanner键盘录入的时候，那时候程序员是如何给程序传参呢？就是借助这里的args传参，怎么用呢？

     1、IDEA可以直接传参

     2、命令传参

         java MainDemo hello world java

public class MainDemo{

    public static void main(String[] args){

       for(int i=0;i<args.length;i++){

          System.out.println(args[i]);

       }

    }

}

【】定义一个类MyMath，提供基本的加减乘除功能，然后进行测试（两个数做操作）

class MyMath{

    private int num1;

    private inrt num2;

    public MyMath(){

    }

    public MyMath(int num1,int num2){

        this.num1 = num1;

        this.num2 = num2;

     }

     public int getNum1(){

        return nim1;

      }

      public void setNum(int num1){

         this.num1 = num1;

       }

       public int getNum2(){

          return num2;

       }

       public void setNum2(inr num2){

           this.num2 = num2;

       //加法运算

       public int add(){

           return num1 +num2;

       }

       //减法运算

       public int sub(){

           return num1 - num2;

      }

      //乘法运算

      public int mul(){

          return num1*num2;

      }

      //除法运算

      public double div(){

          return (num1*1.0) / num2;

       }

}

public class MyMathDemo{

     public static void main(String[] args){

          Scanner sc = new Scanner(System.in);

          System.out.println("请输入第一个操作数");

          int number1 = sc.nextInt();

         System,out.println("请输入第二个操作数");

         int number2 = sc.nextInt();

         MyMath myMath = new MyMath(number1,number2);

         System.out.println("两个数之和为："+myMath.add());

         System.out.println("两数之差为："+ myMath.sub());

         System.out.println("两数之积为："+myMath.mul());

         System.out.println("两数之商为："+myMath.div());

     }

}

四、static

      它可以修饰成员变量，成员方法

       被static 修饰的成员随着类的加载而加载，加载到方法区中

static关键字的特点：它可以修饰成员变量和成员方法

     1、随着类的加载而加载

             观察main方法

     2、优先于对象而存在

      3、被类的所有对象共享：

           举例：所有中国人的国籍都是中国都一样

           什么时候使用静态static关键字呢？

                如果某个成员变量是被所有的成员共享的，值是一样的，那么他就应该被定义为static静态的

          举例：哈罗共享单车（可以用静态的修饰）

                     自己的水杯（不可以用静态的修饰）

       4、可以通过类名直接调用

             一般情况下，只要我们看到一个类中有静态修饰的成员变量，或者是成员方法，我们一律推荐使用：类名.静态成员 这种方式去使用，静态修饰的内容我们一般称为：类成员，与类相关的。

class Student2{

    //非静态的成员变量

    int num = 20;

    //静态的成员变量

     static int num2 = 30;

}

public class StaticDemo1{

    public static void main(String[] args){

          Student2 s1 = new Student2();

          System.out.println(s1.num);

 //        System.out.println(s1.num2);

           System.out.println(Student2.num2);

   }

}      

static关键字使用注意事项： 

      1、在静态方法中是没有this关键字的

            this代表的是当前调用该方法的对象，而被static修饰的成员是优先于对象而存在的

            被static修饰的成员是随着类的加载而加载的，这时候还没有对象产生，也就是说明没有this关键字，所以静态方法中无法使用this关键字

        2、将成员方法分成两类：

              静态的成员方法：

                   访问的内容：

                       成员变量：只能访问静态的成员变量

                       成员方法：只能访问静态的成员方法

                非静态的成员方法：

                     访问的内容：

                          成员变量：既可以访问非静态的成员变量，也可以访问静态的成员变量

                          成员方法：既可以访问非静态的成员方法，也可以访问静态的成员方法

                  总结一句话：静态只能访问静态的

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 int getAgeAgain(){

//       return this.age;

//      }

        public static void fun1(){

              //尝试访问非静态的成员变量name

             //无法从静态上下文中引用非静态 变量name

            //静态的成员方法不能访问非静态的成员变量

//           System.out.println(name);

             //尝试访问非静态的成员方法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){

    }

}

 static内存理解：

class Human{

    //姓名

    private String name;

    //年龄

    private int age;

    //国籍

    //private String country;

      private static String country;

      public Human(){

      }

      public Human(String name,int age){

          this.name = name;

          this.age = age;

     }

     public Human(String name,int age,String country){

          this.name = name;

          this.age = age;

          this.country = country;

     }

// getXxx()和setXxx()

   public void setCountry(String country){

       Human.country = country;

   }

   public void show(){

        Systenm.out.println("姓名："+ name+"，年龄"+age+"，国籍"+ country);

   }

}

public class HumanDemo{

    public static void main(String[] args){

        //创建第一个对象

        Human h1 = new Human("张杰",42m,"中国");

        h1.show();

        //创建第二个对象

        Human h2 =new Human("彭于晏",38);

        h2.show();

        //创建第三个对象

        Human h3 = new Human("蔡徐坤",22);

        h3.show();

    }

}

 

1、定义一个人的类

     我们定义完并使用后发现，姓名和年龄不一样，是变化的，我们可以理解，因为每个人的姓名和年龄都不一样，但是到目前位置，我们选的几个人都是中国人，他们的国籍都一样，都是中国，一样的国籍。我们每次在创建的时候，都会在对内存当中开辟这样的成员变量的空间。

     当一样的国籍人非常多的时候，这样就会造成内存浪费，怎么办呢？

     针对于多个对象有着共同的成员变量，值是一样的时候。

     Java就提供了一个关键字给我们使用，这个关键字叫：static

     static：静态的

     它可以修饰成员变量和成员方法，它的作用是可以让所有的对象共享一个成员变量

class Human{

    //姓名

    private String name;

    //年龄

    private int age;

    //国籍

    //private String country;

      private static String country;

      public Human(){

      }

      public Human(String name,int age){

          this.name = name;

          this.age = age;

     }

     public Human(String name,int age,String country){

          this.name = name;

          this.age = age;

          this.country = country;

     }

// getXxx()和setXxx()

   public void setCountry(String country){

       Human.country = country;

   }

   public void show(){

        Systenm.out.println("姓名："+ name+"，年龄"+age+"，国籍"+ country);

   }

}

public class HumanDemo{

    public static void main(String[] args){

        //创建第一个对象

        Human h1 = new Human("张杰",42m,"中国");

        h1.show();

        //创建第二个对象

        Human h2 =new Human("彭于晏",38);

        h2.show();

        //创建第三个对象

        Human h3 = new Human("蔡徐坤",22);

        h3.show();

        h3.setCountry("加拿大");

        h1.show();

        h2.show();

        h3.show();

    }

}

五、工具类的创建

/**

*这是针对数组相关操作的工具类

*@author 小虎

*@version V.1.0

*

*/

public class ArrayTool{

    /**

     *这是私有的无参构造方法

    */

     private ArrayTool(){

     }

/**

*这是遍历数组的方法，遍历后的格式是[元素1，元素2，元素3……]

*@param array 这是调用该方法时需要传入的参数，数据类型是interesting类型的数组

*/

public static void printArray(int[] array){

    for(int i=0;i<array.length;i++){

        if(i==array.length-1){

            System.out.print("arry[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;strat<=end;start++,end--){

        int temp = array[start];

        array[start] = array[end];

        array[end] = temp;

    }

    return array;

  }

}

六、结合文档注释制作帮助文档