JavaSE笔记_day06_构造方法、静态、Arrays工具类

Person p = new Person(); //()表示调用Person类的构造方法

                    } 

• 注意事项： 

         1.修饰符，多数情况下都使用public。 
         2.构造方法无返回值，连void都不写。 
         3.构造方法的名称必须和所在类的名称完全一致。(文件名 = 类名 = 构造方法名) 
         4.构造方法什么时候调用运行。 
          (1)构造方法不能主动调用,构造方法只能在创建对象时,由JVM主动调用并且运行的。  
          (2)构造方法在每次创建一个对象时，只能执行一次。 
          (3)当创建一个Person对象时，()就表示调用了Person类的无参构造。 
          (4)如果没有编写任何构造方法，那么编译器将会默认赠送一个空参的构造方法。                                 public Student(){ } 
          (5)一旦编写了至少一个带参构造方法，那么编译器将不再赠送。

public Person(){  		public Person(String name ,int age){
    sout("我是空参构造方法");	    sout("我是全参构造方法");
}				    this.name = name;
				    this.age = age;
				} 

举例：
public class TestPerson {//测试Person类中的构造方法
    public static void main(String[] args) {
        /*当创建一个Person对象时，()就表示调用了Person类的无参构造*/
        Person p1 = new Person();//我是无参的构造方法
        System.out.println(p1.getName()+"-----"+p1.getAge());//张三-----20
        Person p2 = new Person("李四",21);//我是全参构造方法
        System.out.println(p2.getName()+"-----"+p2.getAge());//李四-----21
    }
}
public class Person {//构造器的定义
    private String name;//成员变量
    private int age;//成员变量
    /*提供私有成员对应的set和get方法*/
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public Person(){//定义无参构造方法，构造方法内赋值
        System.out.println("我是无参的构造方法");
        name = "张三";//给成员变量进行赋值  == this.name = "张三";
        age = 20;
    }
    public Person(String name,int age){//定义全参构造方法,传参赋值
        System.out.println("我是全参构造方法");
        this.name = name;
        this.age = age;
    }
}

2.构造方法和set方法赋值比较

• 1.构造方法和set方法都是为了给对象的成员变量进行赋值 
• 2.构造方法给成员方法,写法相对简单,但是只能调用一次，只能给对象进行一次赋值，后期想要通过构造方法的二次赋值，做不到，灵活度不够 
• 3.set方法赋值，创建对象成功之后，调用set方法进行赋值，每次调用set方法都可以给成员进行赋值，比较灵活 
•  总结：创建对象时顺便带参数给成员变量赋值简洁，二次用set方法赋值

3.创建对象在内存中的运行过程 (赋默认值 < 显示赋值 < 构造方法参数赋值 )

public class TestPerson {//测试Person类中的构造方法
    public static void main(String[] args) {
        /*当创建一个Person对象时，()就表示调用了Person类的无参构造*/
        Person p1 = new Person();//我是无参的构造方法
        System.out.println(p1.getName()+"-----"+p1.getAge());//张三-----0而不是null----0 显示赋值 > 赋默认值
        Person p2 = new Person("李四",20);
        System.out.println(p2.getName()+"-----"+p2.getAge());//李四----20而不是张三----20 构造方法参数赋值 > 显示赋值
    }
}
public class Person {
    private String name = "张三";//显示赋值
    private int age;//new Person()对象时,JVM赋默认值
    /*提供私有成员对应的set和get方法*/
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public Person(){//定义无参构造方法，构造方法内赋默认值
        System.out.println("我是无参的构造方法");
    }
    public Person(String name,int age){//定义全参构造方法,传参赋值
        System.out.println("我是全参构造方法");
        this.name = name;
        this.age = age;
    }
}

4.this关键字在构造方法中的使用

• this 关键字的使用场景： 

      1.区分成员变量和局部变量 — this.成员变量 、局部变量 
      2.构造方法调用构造方法 — this(构造方法参数);
      说明：this(构造方法参数);  必须放在第一行

二.静态

1.静态的引入

• 举例：定义一个学生对象：姓名、年龄、学号、宿舍号 对于姓名、年龄、学号来说、每个对象都有自己独立的数据。 但是对于宿舍号来说，这应该是多个对象共享一份数据才对。 （宿舍号在类中保存唯一一份，那所有本类对象共享同一份） 
• 如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据。

2.static关键字修饰成员变量

public class Demo01StaticField {
    public static void main(String[] args) {
        Student one = new Student("郭靖",19);
        one.room = "3号楼101";
        System.out.println("学号  "+ one.getId()+" 姓名  "+ one.getName() + " 年龄  "+ one.getAge()+" 宿舍在 "+one.room);
        Student two = new Student("黄蓉",18);
        System.out.println("学号  "+two.getId()+" 姓名  "+ two.getName() + " 年龄  "+ two.getAge()+" 宿舍在 "+two.room);
        one.room = "3号楼201";
        System.out.println("学号  "+two.getId()+" 姓名  "+ two.getName() + " 年龄  "+ two.getAge()+" 宿舍在 "+two.room);//...宿舍在"3号楼201"
    }																													//静态的共享性，类中一改全改
}
    public class Student {
        private int id;
        private String name;
	private int age;
	/*如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据*/
	static String room;//room可以被所有的Student对象共享使用
	private static int idCounter = 0;//学号计数器，每当new了一个新对象的时候计数器++
	public Student() {
	    this.id =  ++idCounter;
	}
	public Student( String name, int age) {
	    this.id = ++idCounter;
	    this.name = name;
	    this.age = age;
	}
	public int getId() {
	    return id;
	}
	public void setId(int id) {
	    this.id = id;
	}
	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 String getRoom() {
	    return room;
        }
        public static void setRoom(String room) {
            Student.room = room;
        }
}

3.静态的特点

• 静态具有共享性,静态属于类,不属于任何一个对象。 
• 静态什么时候进内存? 

       当类的.class文件加载时内存时，类中的所有static修饰的成员(成员变量、成员方 法)， 都随着类的加载一起到进入到内存中，存储在与.class文件相同的内存空间中，叫做方法区(数据共享)。 

• 静态优先于对象存在的 
• 静态修饰的成员可以被所有对象共享使用
• 静态的调用方式： 

  //静态属于类：可以使用类名. 直接调用(推荐) 
  System.out.println(Student.room);//3号楼201
  //可以创建对象，通过对象名调用(不推荐)	
  System.out.println(one.room);//3号楼201

4.static关键字修饰成员方法

public class MyClass {
    int num;//成员变量
    static int numStatic;//静态变量
    public void method(){ //成员方法
    System.out.println("这是一个普通的成员方法。");
    System.out.println(num);//成员方法可以访问成员变量
    System.out.println(numStatic);//成员方法可以访问静态变量
}
public static void methodStatic(){//静态方法     //一旦使用static 修饰成员方法，那么这就成为了静态方法
    System.out.println("这是一个静态方法。");    // 静态方法不属于对象，而是属于类的。
    System.out.println(numStatic);//静态方法可以访问静态变量   
    /*System.out.println(num);错误写法，静态不能直接访问非静态*/
    /*System.out.println(this);错误写法*/
    }
}
public class Demo02StaticMethod {
    public static void main(String[] args) {
        //首先创建对象
        MyClass obj = new MyClass();
        //然后才能使用没有static关键字的内容
        obj.method();//对象名.普通方法名
        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称调用。
        obj.methodStatic();//正确，不推荐 但是这种写法在编译之后也会被javac翻译称为类名称.静态方法名
        MyClass.methodStatic();//正确，推荐  类名称.静态方法

        //对于本类当中的静态方法，可以省略类名称
        Demo02StaticMethod.myMethod();
        myMethod();//完全等效
   }
    public static void myMethod(){
        System.out.println("这是一个自己的方法");
    }
}			

5.静态的注意事项

• 静态不能直接访问非静态 

      原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容

•  静态方法中不能用this关键字(本类对象的引用) 

       原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

•  如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。 

       如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

• 总结： 

      无论是成员变量，还是成员方法。如果是有了static，推荐使用类名称进行调用。 

      静态变量：类名称. 静态变量 
      静态方法：类名称.静态方法()

6.静态变量和非静态变量的区别

1.所属不同
    (1)静态变量属于类
    (2)非静态变量属于对象
2.内存存储位置不同
    (1)静态变量在方法区，与.class文件在同一区域
    (2)非静态变量在堆内存中
3.生命周期不同
    (1)静态变量跟随着类进内存，随着类的全部执行完毕结束(长)
    (2)非静态变量随着对象创建进堆内存，随着对象不再使用结束(短)
4.访问方式不同
    (1)静态变量：类名.直接调用(推荐) 、对象名.调用(不推荐)
    (2)非静态变量：对象名.调用

7.一个标准的类

• 所有的成员变良都要使用private关键字修饰 
• 为每一个成员变量编写一对Getter/Setter
• 编写一个无参数的构造方法 
• 编写一个全参数的构造方法 
• 标准的类也叫做Java Bean 

三.帮助文档和工具类

1.Arrays工具类

Arrays工具类：针对数组进行的操作，来自于JDK中的src.zip压缩包
路径：java.util.Arrays
Arrays类中的所有方法，都是静态的，可以使用Arrays直接调用。
1.sort(int[] arr):能对数组进行排序，升序排列。
2.toString(int[] arr):将参数数组变成字符串(按照默认格式：[元素1，元素2，元素3...])
3.binarySearch(int[] arr,int key):折半查找，获取key值在arr升序数组中的索引值。

import java.util.Arrays;
public class ArraysDemo {//Arrays工具类的使用
    public static void main(String[] args) {
    int[]  arr ={1,2,56,2,7,6,89,74,3};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
    System.out.println(Arrays.binarySearch(arr,74) );
    }
}

2.生成帮助文档

/**
    @author 创作者
    @version JDK版本
    @param 参数，通常写在方法之上
    @return 返回值，通常写在方法之上
*/
举例：
/**
    * @author 张孟伟
    * @version 1.0
**/
public class DocComment {
    public static void main(String[] args) {
					
    }
/**
* 求两个整数类型的和
* @param x,int类型的参数
* @param y,int类型的参数
* @return x+y,两个参数的结果和
* */
    public static int sum(int x,int y ){
        return x + y;
    }
}