JavaSE——构造方法、对象创建、static关键字、Manth随机数功能、代码块

构造方法

• 构造方法概述和作用
  创建对象,给对象中的成员进行初始化

• 构造方法格式特点

  1. 方法名与类名相同
  2. 没有返回值类型，连void都没有
  3. 没有具体的返回值

• 构造方法注意事项

  1. 如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
  2. 如果我们给出了有参数构造方法，系统将不再提供默认的无参构造方法。
     注意： 这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

public class Teacher {
    //1.私有成员变量
    private String name;
    private int age;
    private char sex;
    //2.提供空参和有参构造
    public Teacher(){
	}
    public Teacher(String name,int age,char sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
 //3.提供get set方法

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

给成员变量赋值的两种方式：
a:setXxx()方法
b:构造方法

创建对象

在测试类中创建新对象，对提供属性的类进行操作。通用来说就是new一个对象来操作。

public class MyTest {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.setName("李老师");
        teacher.setAge(24);
        teacher.setSex('男');
        System.out.println(teacher.getName());
        System.out.println(teacher.getAge());
        System.out.println(teacher.getSex());
    }
}

Teacher teacher = new Teacher();

• 构建对象在内存中的具体过程：
  (1):加载 Teacher.class文件进内存
  (2):在栈内存为teacher开辟空间
  (3):在堆内存为老师对象开辟空间
  (4):对老师对象的成员变量进行默认初始化
  (5):对老师对象的成员变量进行显示初始化
  (6):通过构造方法对老师对象的成员变量赋值
  (7):老师对象初始化完毕，把对象地址赋值给teacher变量

static关键字

static 静态的，可以修饰成员变量，也可以修饰成员方法。

• static关键字的特点

  1. 随着类的加载而加载
  2. 优先于对象存在
  3. 被类的所有对象共享
  4. 可以通过类名调用
     其实它本身也可以通过对象名调用。
     推荐使用类名调用。
     静态修饰的内容一般我们称其为：与类相关的，类成员

• static的注意事项

  1. 在静态方法中是没有this关键字的
     （静态是随着类的加载而加载，this是随着对象的创建而存在。静态比对象先存在。）
  2. 静态方法只能访问静态的成员变量和静态的成员方法

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

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

public class Student {
    //实例变量
    public String name="lee";
    //静态变量
    public static int age=23;

    public void show(){
        System.out.println(this.name);
        System.out.println(age);
        System.out.println(this);
    }

    //静态方法中，不能访问非静态变量，只能访问静态变量
    public static void show2() {
        // System.out.println(name); 报错
        System.out.println(age);
        //不能在静态方法里面出现this关键字
        //this代表本类的一个引用，对象。静态的随着类的加载而加载，优先于对象存在。先存在的访问不到后存在的
       // System.out.println(this); //报错
    }

    public void hehe(){
        System.out.println("呵呵");
        this.haha();
    }
    //实例方法
    public void haha() {
        System.out.println("哈哈");
        heihei();
    }
    //静态方法里面不能调用非静态方法
    //静态方法里面只能调用静态所修饰的东西
    public static void  heihei(){
       // this.haha();
        show2();
    }
}

Math类的随机数功能

• Math类概述
  类包含用于执行基本数学运算的方法
• Math类特点
  由于Math类在java.lang包下，所以不需要导包。
  没有构造方法，因为它的成员全部是静态的。
• 获取随机数的方法
  public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
• 获取一个1-100之间的随机数
  int number = (int)(Math.random()*100)+1;

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

import java.util.Scanner;

public class GuessNum {
    public static void main(String[] args) {
        int num=(int)(Math.random()*100)+1;
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入1-100的整数开始猜数游戏：");
       while (true) {
           int cai = scanner.nextInt();
           if(cai>num){
               System.out.println("你猜大啦，继续猜哦");
           }else if(cai<num){
               System.out.println("你猜小咯，接着猜");
           }else {
               System.out.println("恭喜恭喜，猜对啦！！！");
               System.out.println("Game Over");
               break;
           }
       }
    }
}

代码块

• 概述
  在Java中，使用{}括起来的代码被称为代码块。
• 分类
  根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块。
• 常见代码块的应用
  1. 局部代码块
     在方法中出现；限定变量生命周期，及早释放，提高内存利用率
  2. 构造代码块
     在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
  3. 静态代码块
     在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。