day08--Java面向对象--javaobjiect01

今天我们主要学习了如下内容：

1.类和对象的基本概念，类定义的语法
2. 创建对象的语法访问对象成员变量和成员方法的语法
3. 从数据类型的角度理解类和对象，以及对象的内存图解。
4.面向对象特殊语法：

a. 成员变量 VS局部变量
b. 方法形参类型为引用类型时的特殊例子。
c. 构造方法
d. this关键字

1. 面向对象引入

　　回想一下客观世界，我们的客观世界是由两种东西所组成的：

• 生活在客观世界中的个体(客体，或物体)
• 以及个体之间的联系

　　正是由于现实世界中的个体们，“各司其职”, 直接或间接的“相互协作”，才保证了这个世界的正常，有序的流转。

　　我们面向对象的程序世界和现实世界也极其相似：

• 运行中的程序，由多个个体(也就是对象)组成
• 运行中的个体，需要相互协作，共同完成程序的功能

package com.cskaoyan.basic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/14.
 * @version 1.0
 *
 * 面向对象的理解：
 * 1. 类比于现实世界中的个体(客体)，运行中的面向对象程序也是由一个一个的 对象 (个体)组成
 * 2. 所以，要想让面向对象程序运行，必须首先学，构造对象，对象中包含哪些内容呢？
 *    属性：
 *    行为：
 * 3. 也就是说，要想创建一个对象，就必须向jvm描述，对象的 属性和行为 ，但是我们不可能对每一个对象
 *    都去向jvm描述一次，该对象的属性和行为(因为我们的程序中，可能会有成千上万个对象)
 *
 * 4. 如何向jvm描述，我们要创建怎么样的对象呢？  核心从对象的 属性和行为
 *    将同种类型的对象的属性和行为共性,抽取出来  ——> 类（描述对象），描述同种类型的所有对象所具有的属性和行为
 *
 *    类 和 对象
 *
 * 5. 类和对象，以及对象与对象之间的关系
 *    类 VS 对象：
 *    类： 描述，同种类型的对象，共有的属性和行为，但是类描述的是对象有哪些属性，有哪些行为
 *    对象： 对象属性的具体取值，类并没有规定，也就是说，对象属性的具体取值，是由每一个具体的对象自己来决定的
 *
 *    对象 VS 对象：
 *    a: 不同类型的对象，对象可能具有不同的属性和行为
 *    b：同种类型的对象，也有区别，区别就在同种类型的不同对象，他们的属性取值，可以不同
 */
public class Introduction {

}

 

 

package com.cskaoyan.basic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/14.
 * @version 1.0
 *
 * 我们要向让写好的java程序运行起来，
 * 得有对象，所以首相应该学习如何创建对象，但是，要创建对象，必须首先，描述对象 -> 类来描述对象
 *
 * 所以，为了创建出对象，学习类定义，来描述同种类型的所有对象(属性和行为)
 *
 * 定义一个类，类比于现实世界，说明一种类型(属性和行为)
 *
 * 现实中的事物类型(比如人这个类型)：
      属性               人的身高，体重....
      行为               人可以,吃饭，睡觉, 学习，思考……

    Java语言中定义类，也是从这两个方面入手
      成员变量            就是事物的属性
      成员方法           就是事物的行为

      成员变量(对比局部变量)： 成员变量和局部变量定义的位置不同，成员变量定义在，方法体之外
      成员方法(对比我们之前的方法): 之前的方法 修饰符都是 public static，修饰符中去掉static修饰符的方法就是成员方法

      Java中定义类其实就是定义类的成员(成员变量（属性）和成员方法(行为))

 */
public class Demo1 {
  // 成员变量
  int a;


  // 成员方法
  public void memberMethod() {

  }



}

 

2. 面向对象基本概念

　　也就是说，要想写出面向对象的程序，必须首先学会构建面向对象程序的基本组成单位——对象。如何描述一个对象呢？试想下如下场景：

假设你面对一个对地球一无所知的X星人，你要向他描述一只他从未见过的小花猫，你会怎么向他描述呢？

• 属性(外貌)
• 行为

　　那世界上有千千万万只小花猫，如果都要让你描述，你怎么办呢？你显然是无法具体一一描述的。但是这千千万万只小花猫，在属性和外貌上很多的共性 可以把这些共性抽取出来

　　从一般个体中抽取出来的共性，即对某种类型个体的一般性描述(属性和行为)，其实就是类。

　　类：同种物体在属性和行为上的集合与抽象。

类和对象的关系

• 类描述出了，该种类型对象共有的属性和行为
• 类描述了，对象有哪些属性，具备哪些行为(包括行为的具体实现)。
• 但是各个对象的属性取什么值，只有具体的对象能确定。

　　 比如，对于小花猫这个类而言，我们知道 小花猫颜色是花的 小花猫的颜色到底有多花，哪部分花，每个具体的小花猫对象各不相同

 

3. 面向对象基本语法

package com.cskaoyan.basic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/14.
 * @version 1.0
 *
 * 定义一个学生类：
 * 属性(成员变量)：  姓名， 性别， 年龄，学号
 * 行为(成员方法)：  吃饭， 睡觉，学习
 *
 * 有了类定义，我们就有了对同种类型的对象的描述，我们就可以创建学生对象了
 * a. 创建对象
 *    类名  对象名 = new 类名();
 * b. 给对象的属性赋值, 或者访问对象的属性
 *    对象名.属性名
 * c. 访问对象的行为
 *    对象名.方法
 *
 *   类名 对象名 = new 类名();
     对象名.成员变量;
     对象名.成员方法

 */
public class Demo2 {

  public static void main(String[] args) {
    // 类名  对象名 = new 类名();
    Student1 stu1 = new Student1();

    //每个对象，的属性都可以有不同取值
    stu1.name = "zhangsan";
    stu1.age = 20;
    stu1.isMale = true;
    stu1.sno = 1;
    System.out.println(stu1.name + "--" +stu1.age + "--" + stu1.isMale + "--" + stu1.sno) ;

    //访问对象行为
    stu1.eat();


  }

}

/*
    定义学生类，来描述所有学生对象，共有的属性和行为
 */
class Student1 {

  // 姓名
  String name;

  //性别
  boolean isMale;

  //年龄
  int age;

  //学号
  int sno;

  // 学生具有的吃饭行为
  public void eat() {
    System.out.println(name + "吃饭");
  }


  //睡觉行为
  public void sleep() {
    System.out.println("sleeping");
  }

  //学习
  public void study() {
    System.out.println(sno + " 在学习");
  }

}

　　从语法层面再次认识类和对象：

• 回忆一下在基础语法部分我讲过的什么是数据类型？
• 再回忆一下，Java语言中的类的组成，你是否能得到什么启示呢？

package com.cskaoyan.basic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/14.
 * @version 1.0
 *  从语法层面再次认识类和对象：

      1. 回忆一下在基础语法部分我讲过的什么是 数据类型？
         数据类型：一个数据集合和基于这个数据集合的一组操作  byte short int char

      2. 类定义：类体中包括，成员变量和成员方法
         类定义中的数据集合： 成员变量的集合
         类中定义的操作集合： 成员方法集合

      所有说白了，一个类定义，其实就是一种数据类型的定义，这种数据类型，比之于byte，short，int，char，
      不一样，因为，我们自己定义的类 -> 其实是coder的自定义数据类型，所以jvm天生不认识

     那么，一旦我们将类看做是一种自定义数据类型，类和对象的关系，就可以类比于基本数据类型 和 基本数据类型变量之间的关系
     int a;
     Student1 st = new Student1();

 *
 */
public class Demo3 {

}

 

 

4. 内存中的“对象”

package com.cskaoyan.basic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/14.
 * @version 1.0
 *
 *  从内存的角度，理解对象：
 *
 *  1个对象的内存图
     一个对象的基本初始化过程

    3个对象的内存图
     其中有两个引用指向同一个对象

 */
public class Demo4 {

  public static void main(String[] args) {

    // 类名  对象名 = new 类名();
    Student2 stu1 = new Student2();
    //每个对象，的属性都可以有不同取值
    stu1.name = "张三";
    stu1.age = 20;
    stu1.isMale = true;
    stu1.sno = 1;
    //System.out.println(stu1.name + "--" +stu1.age + "--" + stu1.isMale + "--" + stu1.sno) ;

    Student2 stu2 = new Student2();
    //每个对象，的属性都可以有不同取值
    stu2.name = "李四";
    stu2.age = 20;
    stu2.isMale = true;
    stu2.sno = 1;
    //System.out.println(stu1.name + "--" +stu1.age + "--" + stu1.isMale + "--" + stu1.sno) ;

    //访问对象行为
    //stu1.eat();
    //stu2.eat();


    // stu1 和 stu3， 指向了同一个对象
    Student2 stu3 = stu1;

    stu3.name = "王五";

    System.out.println(stu1.name);

  }

}

/*
    定义学生类，来描述所有学生对象，共有的属性和行为
 */
class Student2 {

  // 姓名
  String name;

  //性别
  boolean isMale;

  //年龄
  int age;

  //学号
  int sno;

  // 学生具有的吃饭行为
  public void eat() {
    System.out.println(name + "吃饭");
  }


  //睡觉行为
  public void sleep() {
    System.out.println("sleeping");
  }

  //学习
  public void study() {
    System.out.println(sno + " 在学习");
  }

}

1个对象的内存图

　　一个对象的基本初始化过程

 

 图：一个对象的内存映像

 

3个对象的内存图

　　其中有两个引用指向同一个对象

 

 图：多个对象的内存映像

 

 

5. 面向对象“特殊”语法

　　

　　在学习类(Class)的时候，我们引入了一种和之前不太一样的变量——成员变量。其实，之前我们在代码中所使用的所有的变量都是局部变量。

　　哪些变量是局部变量？ 方法中定义的变量和方法的形式参数 

package com.cskaoyan.syntax.variable;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/14.
 * @version 1.0
 *
 *   成员变量： 定义在类体中，方法体之外的变量
 *   哪些变量是局部变量？ 方法中定义的变量和方法的形式参数

    局部变量和成员变量的比较：
    1. 在类中定义的位置不同

    2. 在内存中的位置不同
       a. 局部变量，都是存储在方法对应的栈帧中的
       b. 成员变量，存储在堆上，在对象的内存中
    3. 初始化值不同
       a. 局部变量，局部变量没有天生的初始值，必须在使用之前，用代码初始化成员变量的值
       b. 成员变量，成员变量存储在堆上的，堆上的成员变量，天然有默认初值

    4.生命周期不同
      a. 因为局部变量是存储在栈帧中的，因此，随着栈帧的存在而存在，随着栈帧的销毁而销毁
      b. 成员变量，因为成员变量，是在堆上，对象的内存空间中，
         成员变量随着对象的存在而存在，随着对象的销毁而销毁(当对象无法被使用的时候，也就是说对象变成垃圾的时候)

 */
public class Demo1 {

  int intValue;



  public void test() {
    int i = 10;
    System.out.println(i);

    System.out.println(intValue);
  }

}

 

　　在进入面向对象之后，大家应该也已经清楚了，引用变量的含义。 我们知道，在方法定义中的形式参数的类型，既可以是基本数据类型，也可以是引用变量类型。 那么，当方法的参数类型是引用类型的时候，在方法的形参与实参进行值传递的时候，就会引起新的问题，接下来我们做一个练习。

这两段代码实现的功能有什么不同呢，为什么？

代码1

package com.cskaoyan.syntax.method.excercise;

/**
 * @version 1.0
 */

class Demo1 {
  int a;
}

public class TestQuote1 {

  public static void main(String args[]) {
    Demo1 d1 = new Demo1();
    d1.a = 1;

    Demo1 d2 = new Demo1();
    d2.a = 2;

    System.out.println(d1.a);
    System.out.println(d2.a);
    function(d1, d2);
    System.out.println(d1.a);
    System.out.println(d2.a);
  }

  // 方法的参数类型，都是引用类型
  private static void function(Demo1 d1, Demo1 d2) {
    //交换 d1 和 d2这两个引用变量所指向的对象的 成员变量a的值
    int a;
    a = d1.a;
    d1.a = d2.a;
    d2.a = a;
  }
}

代码2

package com.cskaoyan.syntax.method.excercise;

/**
 * @version 1.0
 */
class Demo2 {
  int a;
}

public class TestQuote2 {

  public static void main(String args[]) {
    Demo2 d1 = new Demo2();
    d1.a = 1;

    Demo2 d2 = new Demo2();
    d2.a = 2;

    System.out.println(d1.a);
    System.out.println(d2.a);
    function(d1, d2);
    System.out.println(d1.a);
    System.out.println(d2.a);
  }

  private static void function(Demo2 d1, Demo2 d2) {
    Demo2 temp;
    temp = d1;
    d1 = d2;
    d2 = temp;
  }
}

 

　　代码1中的输出发生了改变，代码2中的输出没变。究其结果，看内存图中的各参数变化。

 

 

 图：代码1的内存映像

 

  图：代码2的内存映像

 

　　回忆一下我们之前是如何给对象的属性赋值的？

　　 　　对象名.成员变量名 = 成员变量值

　　其实Java语言还提供了另外一种方式，帮助我们完成对成员变量(对象属性)的初始化——对象的构造方法

　　构造方法的作用： 就是使得jvm在构造对象的时候，帮助我们进行成员变量的初始化。

• 构造方法的格式
• 构造方法的注意事项

package com.cskaoyan.syntax.constructor;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/14.
 * @version 1.0
 *
 * 回忆一下我们之前是如何给对象的属性赋值的？
      对象名.成员变量名 = 成员变量值

   类比于，数组的静态初始化方式，那创建对象的时候，是否可以，用某种方式，
          把对象成员变量的值，初始化成我们想要的初始值。而不要我们对每一个成员变量，手动赋初值

   通过一种，特殊的方法(定义在类中) -> 构造方法，就可以完成以上功能，即创建对象之后，
   将对象的成员变量的值，初始化成我们想要的值

   构造方法的作用：就是使得jvm在构造对象的时候，帮助我们进行成员变量的初始化。


1. 首先，在类中，定义构造方法语法, 有两个不同于一般方法的地方
   a. 构造方法的方法名固定，和类名相同 (这一点，java语言的语法规范，所以构造方法命名，确实违反了驼峰命名规则)
   b. 构造方法(没有返回值)的方法声明中，没有返回值这一项
      当一个普通方法没有返回值 void

   注意事项：
   1. 一个类中可以，定义多个重载的构造方法
   2. 我们需要知道，其实，当我们没有在类中定义任何一个构造方法的时候，
      jvm会自动添加一个默认的构造方法(无参构造方法)
      但是，一旦我们自己在类定义中，定义了哪怕只有一个构造方法，jvm就不会在自动帮我们添加那个无参构造方法了

      jvm为什么这么干？ 这和jvm执行固定流程有关系

      开辟对象的存储空间 -> 给对象成员变量赋予默认初值 -> 使用构造方法，初始化对象成员变量的值

   3. 构造方法何时执行呢？
      由jvm，来真正调用执行的，在创建对象的最后一步，执行构造方法，给对象的成员变量赋予Coder传递的初值
 *
 */
public class Demo1 {

  public static void main(String[] args) {
    // 类比数组引出构造方法
    //introduce();


    //使用四参构造方法
    //Student zhangsan = new Student("zhangsan", false, 18, 1);
    //System.out.println(zhangsan.name + "--" + zhangsan.isMale + "--" + zhangsan.age + "--" + zhangsan.sno);

    //使用2参构造方法
    //Student lisi = new Student("lisi", 20);
    //// lisi--false--20--0
    //System.out.println(lisi.name + "--" + lisi.isMale + "--" + lisi.age + "--" + lisi.sno);


    //以最简单的方式，不对成员变量值初始化的方式
    //其实这种方式，就等价于，告诉jvm使用无参构造方法，来初始化成员变量的值
    Student stu = new Student();
    System.out.println(stu.name + "--" + stu.isMale + "--" + stu.age + "--" + stu.sno);
  }

  private static void introduce() {
    //类比于数组
    int[] arr = new int[3];
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;

    //数组，还有一种初始化数组元素值的方式
    int[] arr1 = {1, 2, 3};
  }

}

/*
    定义学生类，来描述所有学生对象，共有的属性和行为
 */
class Student {

  // 姓名
  String name;

  //性别
  boolean isMale;

  //年龄
  int age;

  //学号
  int sno;

  ////不接收任何参数，无参构造方法
  public Student() {
    name = "未知";
    isMale = true;
    age = -1;
    sno = -1;
    System.out.println("Student()");
  }

  // 定义一个接收两个参数的，构造方法
  public Student(String nameValue, int ageValue) {
    System.out.println("Student(String nameValue, int ageValue)");
    name = nameValue;
    age = ageValue;
  }

  //定义构造方法 用来初始化，对象中成员变量的值
  public Student(String nameValue, boolean isMaleValue, int ageValue, int snoValue) {
    System.out.println("Student(String nameValue, boolean isMaleValue, int ageValue, int snoValue)");
    name = nameValue;
    isMale = isMaleValue;
    age = ageValue;
    sno = snoValue;
  }




  // 学生具有的吃饭行为
  public void eat() {
    System.out.println(name + "吃饭");
  }


  //睡觉行为
  public void sleep() {
    System.out.println("sleeping");
  }

  //学习
  public void study() {
    System.out.println(sno + " 在学习");
  }

}

 

this关键字：代表对象自身的引用

this关键字的作用：

• 解决成员变量的隐藏的问题
• 访问对象的成员
• 访问对象的构造方法

package com.cskaoyan.syntax.keythis;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/14.
 * @version 1.0
 *
 * 成员变量的隐藏问题：
 *   1. 方法中定义了和类中同名的成员变量
 *   2. 在方法体中，通过通过同名变量的，变量名来访问变量值，我只能访问到方法中的，
 *      那个局部同名变量的值，而访问不到，同名成员变量的值
 *   3. 在方法体中，就好像同名成员变量，被同名局部变量给隐藏起来了
 *
 * 如何解决成员变量的隐藏问题呢？ 核心，就是在方法体中，以某种方式，区分同名成员变量和同名局部变量
 * 引入一个关键字 this, 帮助我们解决了，成员变量的隐藏问题
 *
 *  正式学习this关键字
 *   this关键字：代表 （对象自身）当前对象 的引用
 *   当前对象：
 *   a. 在构造方法中的 this，指代的当前对象，其实就是，构造方法执行时，jvm正在创建的那个对象
 *   b. 在普通成员方法的方法体中，this，指代的对象是谁？
 *      对于普通成员方法而言  对象名.方法(),
 *      所以对于普通成员方法而言，在到那个对象上掉调用方法，方法中的this就指的是哪个对象
 *
 *  this关键字的作用：
      1. 解决成员变量的隐藏的问题
      2. 访问对象的成员(访问当前对象的成员变量值，访问当前对象的成员方法)
      3. 访问对象的构造方法  this(实参列表) 在某个构造方法中，调用其他构造方法
         a. this调用构造方法，这个代码，只能某个构造方法的方法体中
         b. this调用构造方法, 必须处在构造方法的第一条语句的位置

 *
 *
 */
public class Demo1 {

  public static void main(String[] args) {

    String name = "wuliuqi";
    int age = 20;
    Student stu1 = new Student(name, age);
    // null--false--0--0
    //System.out.println(stu1.name + "--" + stu1.isMale + "--" + stu1.age + "--" + stu1.sno);

    Student shisan = new Student("shisan", 18);
    //对象名.的形式
    stu1.eat(); // wuliuqi吃饭
    shisan.eat(); // shisan吃饭

    Student student = new Student();
    //
  }

}
/*
    定义学生类，来描述所有学生对象，共有的属性和行为
 */
class Student {

  // 姓名
  String name;

  //性别
  boolean isMale;

  //年龄
  int age;

  //学号
  int sno;

  // 在无参构造方法中，给name，age成员赋予我们自己的默认初值
  public Student() {
    //this.name ="未知";
    //this.age = -1;

    //在构造方法中，调用其他构造方法
    this("未知", -1);

  }

  // 成员变量的隐藏问题
  // 定义一个接收两个参数的，构造方法
  public Student(String name, int age) {

    System.out.println(name);
    this.name = name;
    this.age = age;
    System.out.println("constructor");
  }

  // 学生具有的吃饭行为
  public void eat() {
    System.out.println(this.name + "吃饭");

    //调用普通成员方法
    this.test();
  }

  public void test() {

  }

}