this关键字

当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题。

this关键字代表当前类的引用，简单地说就是代表当前类的一个对象，谁调用这个方法，这个方法的内部的this就代表谁。

public class TestThis {

        public static void main(String[] args) {
            A a = new A();
            System.out.println(a);
            int num=10; //定义在栈内存中
            a.show(num,a);
            System.out.println(num); //10
        }
    }

    class A{
        int num=100;  //定义在堆内存中
        public void show(int num, A a){
            System.out.println(this); //本类引用
            System.out.println(num); //10
            System.out.println(a.num); //100
            System.out.println(this.num);  //100
            System.out.println(a==this);

    }
}

输出：
org.westos.homework0406.A@1540e19d
org.westos.homework0406.A@1540e19d
10
100
100
true
10

构造方法

作用

创建对象时为对象中的成员进行初始化
特点

方法名与类名相同
么有具体的返回值类型
方法声明不写返回值类型，void也不用
注意事项

如果没有自定义构造方法，系统会自动提供一个空参构造；若给出了有参构造，系统将不再提供空参构造，如果还需要空参构造，必须手动给出
给成员变量赋值的两种方式
a:setXxx()方法

b:构造方法

案例：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 void sleep() {
        System.out.println("睡觉");
    }

    public void eat() {
        System.out.println("吃饭");
    }
}

static关键字

static 静态的可以修饰成员变量，和成员方法
被static所修饰的成员变量，是一个共享变量，被类的所有对象所共享
被静态所修饰的成员，是随时类的加载而加载（随着 .class文件进内存，静态的东西就会加载）

优先于对象而存在

案例：

public class Person {
    public String name;

    public static String country = "中国";
}

public class MyTest {
    public static void main(String[] args) {
        //想让中国，让这个三个对象共享
        Person person = new Person();
        person.name="张三";
        person.country="美国";
        System.out.println("---------------");
        Person person2 = new Person();
        person2.name = "李四";
        person2.country = "新加坡";

        System.out.println("---------------");
        Person person3 = new Person();
        person3.name = "王五";

        person3.country = "英国";

        System.out.println(person.name+"----"+person.country); //张三---英国
        System.out.println(person2.name + "----" + person2.country); //李四---英国
        System.out.println(person3.name + "----" + person3.country); //王五---英国
    }
}

static关键字的特点

随着类的加载而加载
可以通过类名调用
优先于对象存在
被类的所有对象共享
注意事项：

静态方法中不能使用this关键字，this表示本类的引用，即一个对象，而静态是虽类的加载而加载的，静态比对象先存在

静态方法只能访问静态成员变量和静态成员方法（静态只能访问静态）

静态变量和成员变量的区别

在内存中位置不同

静态变量存储在方法区的静态区
成员变量存储在堆内存
所属不同

静态变量属于类（类变量）
成员变量属于对象（实例变量/对象变量）
生命周期不同

静态变量随类的加载而加载，随类的消失而消失
成员变量随对象的创建而存在，随对象的消失而消失
调用方式不同

静态变量既可以通过类名调用，也可以通过对象调用

成员变量只能通过对象调用

Math类的随机数功能

Math类包含用于执行基本数学运算的方法，由于Math类在java.lang包下，所以不需要导包。Math类没有构造方法，因为它的成员全部是静态的。

获取随机数的方法

public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。若要获取一个1-100之间的随机数，可int number = (int)(Math.random()*100)+1;

案例：猜数字小游戏(数据在1-100之间)

import java.util.Scanner;

public class RandomGame {
    public static void main(String[] args) {
        System.out.println("请输入一个数1~100");
        Scanner scanner = new Scanner(System.in);
        int answer = (int) (Math.random()*100+1);
        int index = 1;
        while (index<=10){
            int num = scanner.nextInt();
            if(num>answer){
                System.out.println("猜大了");
                System.out.println("你还剩"+(610-index)+"次机会");
                index++;
            }else if(num<answer){
                System.out.println("猜小了");
                System.out.println("你还剩"+(10-index)+"次机会");
                index++;
            }else {
                System.out.println("恭喜你，猜对了");
                break;
            }
        }
    }
}