Java语言基础day06（面向对象private，this，static关键字，构造方法，Math类的随机数）

面向对象

• 成员变量和局部变量的区别

  1. 在类中的位置不同：成员变量在类中方法外，局部变量在方法定义中或者方法的声明上（形参）。

  2. 在内存中的位置不同：成员变量在堆内存，局部变量在栈内存。

  3. 声明周期不同：成员变量随着对象的建立而建立，随着对象的消失而消失。

     ​ 局部变量随着方法的调用而存在，随着方法调用完毕而消失。

  4. 初始化值不同：成员变量有默认的初始化值。局部变量没有默认初始化的值，只能定义 ，赋值，才能使用。

• 匿名对象

  匿名对象：就是没有名字的对象

  适用于仅仅使用调用一次的时候，或者作为实际参数传递。

  public class MyTest2 {
      public static void main(String[] args) {
          Cat cat = new Cat();
          //若果看到一个方法的形参，要一个类的 类型，那么你就传递一个该类的对象
          cat.show(cat,19);
          System.out.println(cat.num);//19
          System.out.println("-----");
          //匿名对象作为参数传递
          cat.show(new Cat(),20);
          System.out.println(cat.num);//20
      }
  }
  class Cat{
      int num=1000;
      public void show(Cat cat,int num){
          cat.num=num;
          System.out.println(num);//19
      }
  }
  

  Teacher teacher = new Teacher();
          teacher.show();
          teacher.show2();
          int num1=teacher.num;
          System.out.println(num1);//100  这是对同一个对象进行调用
  
          //匿名对象的调法
          new Teacher().show();//每new一次就建立一个对象，是对不同对象进行调用的
          // ，适合于一次调用的类型，对同一个对象进行多次调用，最好进行命名
          new Teacher().show2();
          new Teacher().show();
  
          //匿名对象调用成员变量
          int num=new Teacher().num;
          System.out.println(num);
  

• 封装

  封装：隐藏对象的属性和实现细节，仅对外提供公共的访问模式。

  封装的好处：

  1. 隐藏实现细节，提供公共的访问方式。
  2. 提高了代码的复用性
  3. 提高了安全性

  封装的原则：

  1. 将不需要对外提供的信息隐藏起来。
  2. 把属性隐藏起来，提供公共访问法对其访问。

• private关键字

  private 权限修饰符 是私有的。可以修饰成员变量和方法成员，被修饰后，只能在本类中访问，不能由外界访问
  public 公共权限修饰符，是公共的，可以修饰成员变量和成员方法，被修饰的成员在任何地方都能访问

• this关键字

  成员变量和形参名相同时，不使用this关键字，就会导致的问题：局部变量隐藏了成员变量

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

  快速生成set，get的方法 alt+Inset 弹出一对话框，选择get，set

  public class MyTest {
      public static void main(String[] args) {
          //新建一个老师的对象
          Teacher teacher = new Teacher();
          System.out.println(teacher);
          //通过set来设置成员变量
          teacher.setName(teacher,"王老师");
          teacher.setAge(30);
          //通过调用get方法来获取成员变量的值
          String name = teacher.getName();
          int age = teacher.getAge();
          System.out.println(name);
          System.out.println(age);
          System.out.println("---------");
          //this 代表了本累的一个引用，你可以理解为本类的一个对象，
          // 那个对象调用某个方法，那么方法中的this就表示这个对象
          Teacher teacher1 = new Teacher();
          teacher1.setName(teacher1,"李老师");
          System.out.println(teacher1);
          teacher1.setAge(27);
          String name1 = teacher1.getName();
          int age1 = teacher1.getAge();
          System.out.println(name1);
          System.out.println(age1);
  
      }
  }
  

  public class Teacher {
      //私有的成员变量
      private String name;
      private int age;
  
      //提供set方法，可以让外界通过调用set方法来对成员变量的值设置
      public void setName(Teacher teacher,String name){
         // name =  name;成员变量和局部变量重名
          //根据就近原则，这句语句中第一个name引用的是传递过来的形参，
          // 不是距离较远的对象的成员变量名name，我们在这需要的是对象的成员变量，
          // 所以需要this这个关键字标注，表示引用的对象的成员变量。
         // this.name=name;
          teacher.name=name;
          System.out.println(teacher);
  
      }
      public void setAge(int age){
          this.age = age;
      }
      //提供get方法，让外界通过对get方法的调用来获取成员变量的值
      public String getName(){
          return name;
      }
      public int getAge(){
          return age;
      }
      public void teacher(){
          System.out.println("教书");
      }
  }
  

• 构造方法

  构造方法作用是创建对象，给对象中的成员进行初始化

  构造方法的特点：方法名与类名相同，没有返回值，连void也没有，没有返回具体的值。

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

  public class MyTest2 {
      public static void main(String[] args) {
          //采用空参构造来创建对象
          Student student = new Student();
          student.setName("王明");
          student.setAge(19);
          System.out.println(student.getName());
          System.out.println(student.getAge());
          System.out.println("-----------");
  
          //采用有参数构造来创建对象，在创建对象的同时，就可以给成员变量赋值
          Student student1 = new Student("王梅",18);
          System.out.println(student1.getName());
          System.out.println(student1.getAge());
      }
  }
  

  public class Student {
      private String name;
      private int age;
      //构造方法：方法名和类名相同，没有返回值类型，连void也没有
      //我们自定义的一个类中，默认就会存在一个空参的构造方法
      //构造方法就是用来初始化这个类，完成对类的实体化
      public Student(){
          System.out.println("空参的构造方法执行了");
      }
  
      public Student(String name){
          System.out.println(name);
          System.out.println("一个参数的构造方法执行了");
      }
      public Student(String name,int age){
          System.out.println(name);
          System.out.println(age);
          System.out.println("两个参数的构造方法执行了");
      }
  
      //提供set get方法
  
      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;
      }
  }
  

• static关键字

  在静态方法里面只能访问静态变量，不能访问非静态变量，先存在的不能访问后存在的。在非静态方法里面，既可以访问静态的也可以访问非静态的。

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

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

• Math类的随机数功能(Math)

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