学习Java的第五天 | 定义方法 | 引用数据类型——类 | 访问权限-修饰符 | 全局变量与局部变量 | toString | 构造方法 | 方法重载

前面提到的，冒泡排序，二分查找，我们有时候写代码可能不止要查到一种数组的数据，这时候我们就很需要想循环那样的结构，来帮我们解决代码冗余的情况。
我们前面使用的main方法，是一个java程序的入口，我们可以把我们的冒泡排序、二分查找的方法的代码，写在方法里，不是方法套方法哦，这是不允许的。

1 定义方法

定义方法，可以这样分类：
1 、方法的（ ） ，括号中如果有填入形参，就是 有参方法（形参） ，没有的话，就是 无参方法（）
2、方法是否有返回值，且根据返回值的类型选择 如果是无返回值，就是void ，如果返回int，就用int，如果是有返回值类型的，切记要加上return。
下面来分析一下二分查找的这个代码

public class Test02 {
    public static void main(String[] args) {
        int[] array = new int[10000];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        //后半部分，是给二分查找方法传入主方法的数据，前半部分是，得到其返回值
        //不然我们只调用了这个方法，就没有去得到我们想要的值，无论是没有找到的-1
        //还是找到的那个值，就没有意义
        int r = search(array,8888);
        System.out.println(r);
    }
    //返回值类型为 int 类型 ，且是有参方法 
    public static int search(int[] arr, int a){
        int start = 0;
        int end = arr.length - 1;
        while(start<=end){
            int middle = (start + end)/2;
            if (arr[middle] == a){
            	//如果要查找的这个数就是中间值，我们主方法中需要这个值，我们得返回
                return middle;
            }else if (a > arr[middle]){
                start = middle + 1 ;
            }else if (a < arr[middle]){
                end = middle - 1 ;
            }
        }
        //如果数组找不到这个值，就返回-1，以告诉程序员。
        return -1;
    }
}

2 引用数据类型——类

在java中只要创建了一个类，就是一个数据类型，类是一个模板，只有特征，没有具体数据
根据类在每个特征上输入对应的值，就会形成数据。

在java中 创建数据 需要用到关键词——new

//这个cat是对象，就是类中的一个实例
Cat cat = new Cat();

public void Cat(){
	public String name ;
	public int age ;
	public String type ;
}

创建了特征后，需要对其进行赋值，如果不赋值，也会有默认值，默认值参考第四天的内容

cat.name = "胖熊";
cat.age = 1 ;
cat.type = "英短";

获取一条具体的数据

System.out.println(cat.name+cat.age+ "岁" +cat.type);

在给特征赋值的时候，有可能会涉及到一些判断，比如说，没有负岁数的对象，所以，对其特征赋值的时候，我们可以在类里的岁数的特征，对其进行判断

set方法进行赋值的时候，参数本来就是给属性复制的，赋值时候，变量名要加后缀，不能和属性重名，这里涉及一个局部变量与全局变量的重名问题

public void setAge(int age) {
    if (age > 0){
        this.age = age;
    }else {
        age = 0 ;
    }
}

3 访问权限-修饰符

虽然我们对特征进行判断，但是在访问特征的时候，我们现在使用的方式是点访问，就还是可以随心所欲的将猫咪设成不可能是岁数。相对的，有另一种比较安全访问private，这种修饰符下的特征则需要通过特殊的方式进行访问，就不会随便接受不合理的赋值了

public class Cat {
    private String name;
    private int age;
    private String type;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0){
            this.age = age;
        }else {
            age = 0 ;
        }
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("胖熊");
        cat.setAge(1);
        cat.setType("英短 纯白");
        System.out.println(cat.getName()+cat.getAge()+ "岁" +cat.getType());
    }
}

private修饰的特征叫属性，属性私有化，给私有属性赋值和取值的方式就是 set get
不知不觉中，我们就把封装给诠释了出来，封装就是一个保护罩，保护代码和数据，避免被外部类定义的代码随便访问，要访问该类的代码和数据，必须通过严格的接口控制，封装的最主要的功能就在于 ，我们能修改自己的实现代码，而不用修改那些调用了这些代码的程序
适当的封装，加强了程序的安全性。

4 全局变量与局部变量

如果写在类中特征的属性的作用范围就是当前类——全局变量 类中定义
如果变量在方法内定义或者方法参数上定义 作用范围就是当前方法——局部变量 方法中定义
局部变量距离使用的变量近
全局变量距离使用的变量远
局部变量是方法中的一个参数
全局变量是类中的一个属性
this关键字区别局部变量和全局变量 this.当前变量=值
在我们的案例中，现在使用的是哪个对象 this就是谁 ，谁现在调用了set方法 this就是谁

public void setAge(int age) {
        if (age > 0){
            this.age = age;
        }else {
            age = 0 ;
        }
        //类中的当前对象
        System.out.println(this);
    }

public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("胖熊");
        cat.setAge(1);
        cat.setType("英短 纯白");
        //System.out.println(cat.getName()+cat.getAge()+ "岁" +cat.getType());

        System.out.println(cat);

        Cat cat1 = new Cat();
        cat1.setAge(1);
        System.out.println(cat1);
    }

输出：
Demo.Cat@1b6d3586
Demo.Cat@1b6d3586
Demo.Cat@4554617c
Demo.Cat@4554617c

5 toString

在上面的代码中，我们获取一个对象的全部数据的时候，我们会自己拼接起来，实际上在java中，有一个toString方法，在对象被打印的时候，会被默认调用。

@Override
public String toString() {
    return "Cat{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", type='" + type + '\'' +
            '}';
}

public class Test01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("胖熊");
        cat.setAge(1);
        cat.setType("英短 纯白");
        System.out.println(cat);
    }
}

输出：
Cat{name='胖熊', age=1, type='英短 纯白'}

6 构造方法

只要我们创造了类，在类中就会有一个默认的无参构造方法，这个构造方法就是为了给我们进行对象的创建

public Cat() {
}

只要我们自己写了构造方法，其默认的构造方法就会失效。
现在写一个带参的构造方法，有了这个构造方法，创建对象的时候，就会指引我们如何创建，我们就按照格式创造就可以，边创造边赋值。

//带参构造方法
public Cat(String name, int age, String type) {
        this.name = name;
        this.age = age;
        this.type = type;
    }

Cat cat = new Cat("胖熊",1,"英短 纯白");

7 方法重载

一个类中不能有两个相同的方法，但是我们在创造对象的时候，不想要它因为我们的有参构造方法的存在而报错，可以使用方法重载

在一个类中，方法名相同，参数列表不同 就是方法重载
参数列表不同可以是以下表现：
1、参数的个数不同 无参 有参
2、参数的顺序不同 String int int String
3、参数的类型不同 int String