Learning Java Day08

创建对象内存分析

小结

1. 类与对象

   类是一个模板：抽象，对象是一个具体的实例

2. 方法

   定义、调用！

3. 对象的引用

   引用类型、基本类型（8）

   对象是通过引用来操作的：栈 --> 堆

4. 属性

   字段Filed -- 成员变量

   默认初始化

   数字 -- 0 / 0.0

   char -- u0000

   boolean -- false

   引用 -- null

   修饰符 属性类型 属性名 = 属性值！

5. 对象的创建和使用

   • 必须使用 new 关键字创造对象，构造器 Person Harryking = new Person();

   • 对象的属性 Harryking.name

   • 对象的方法 Harryking.sleep()

6. 类

   静态的属性 -- 属性

   动态的行为 -- 方法

封装

• 该露的露，该藏的藏

  我们程序设计要追求”高内聚，低耦合“

  高内聚 -- 类的内部数据操作细节自己完成，不允许外部干涉

  低耦合 -- 仅暴露少量的方法给外部使用

• 封装（数据的隐藏）

  通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息的隐藏

• 记住这句话就够了 -- 属性私有，get / set

 import com.Harryking.www.demo.Student;
 ​
 public class Application {
     public static void main(String[] args) {
         Student s1 = new Student();
         //s1.name 报错，属性私有
 ​
         s1.setName("Harryking");
         //看一个方法是否相同 -- 方法名 参数列表
         //都相同为同一方法、仅方法名相同是为重载
         System.out.println(s1.getName());
 ​
         s1.setAge(-1);//不合法的
         System.out.println(s1.getAge());
     }
 }

 //类
 //封装大多数时候是对于属性来的
 //封装核心 private -- 私有
 /*
 封装的意义：
 1.提高程序的安全性，保护数据
 2.隐藏代码的实现细节
 3.统一接口，形成规范
 4.系统的可维护性增加，便于修改内部代码
  */
 public class Student {
     //属性私有
     private String name;//名字
     private int id;     //学号
     private char sex;   //性别
     private int age;
     //提供一些可以操作这个属性的方法！
     //提供一些pubilc的get、set方法
     //get 获得这个数据
     public String getName() {
         return this.name;
     }
     //set 给这个数据设置值
     //内部可增加安全性验证的判断
     public void setName(String name) {
         this.name = name;
     }
     //学习()
     //睡觉()
 ​
     //快捷键 ALT + INS
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         if (age > 120 || age < 0)
         {
             this.age = 3;
         } else {
             this.age = age;
         }
     }
 }

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好地建模

• extends的意思是”扩展“，子类是父类的扩展

• JAVA中类只有单继承，没有多继承！ -- 一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

1. 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等

   • 组合 -- 在一个类中使用其他类的属性或者方法

2. 继承关系的两个类，一个为子类 -- 派生类，一个为父类 -- 基类，子类继承父类，使用关键字extends来表示

3. 子类和父类之间，从意义上来讲应该具有 "is a" 的关系

• object类

• super -- this

• 方法重写

 //在Java中，所有的类都默认直接或者间接继承Object
 //Person 人 -- 父类
 public class Person /*extends Object*/ {
     //public -- 公共的
     //protected -- 受保护的
     //default -- 默认的(可不写)
     //private -- 私有的 子类不可使用 一般只有属性是私有的
     private int money = 10_0000_0000;
 ​
     public void say() {
         System.out.println("说了一句话");
     }
 ​
     public int getMoney() {
         return money;
     }
 ​
     public void setMoney(int money) {
         this.money = money;
     }
     //快捷键 CTRL + H -- 打开继承树
 }

 //学生 is 人 -- 派生类、子类
 //子类继承了父类，就会拥有父类的全部方法
 public class Student extends Person {
 }

 import com.Harryking.www.demo.Person;
 import com.Harryking.www.demo.Student;
 ​
 public class Application {
     public static void main(String[] args) {
         Student student = new Student();
         student.say();
         //System.out.println(student.money);报错 money私有
         
         Person person = new Person();
     }
 }

super详解

 //在Java中，所有的类都默认直接或者间接继承Object
 //Person 人 -- 父类
 public class Person /*extends Object*/ {
     //默认无参构造器 -- 正常情况调用对象默认先走无参构造器
 ​
     public Person() {
         System.out.println("Person无参构造执行了");
     }
 ​
     protected String name = "Harrgking";
     /*
     私有的东西无法被继承
     private void print() {
         System.out.println("Person");
     }
      */
     public void print() {
         System.out.println("Person");
     }
 }

 //学生 is 人 -- 派生类、子类
 //子类继承了父类，就会拥有父类的全部方法
 public class Student extends Person {
     public Student() {
         //隐藏的默认代码 -- 调用了父类的无参构造器
         //因此，若是父类没有无参构造则报错，可以通过手动写有参构造来解决 super(...);
         //super(); -- 调用父类的构造器，必须在子类无参构造器的第一行，否则报错
         //this();的调用，同理必须写在第一行
         // 因此this和super不能同时使用，因为第一行只能有一个语句
         System.out.println("Student无参构造执行了");
     }
 ​
     private String name = "卢威";
 ​
     public void print() {
         System.out.println("Student");
     }
 ​
     public void test1 (String name) {
         System.out.println(name);
         System.out.println(this.name);
         System.out.println(super.name);
     }
 ​
     public void test2 () {
         print();        //Student
         this.print();   //Student
         super.print();  //Person
     }
 }

 import com.Harryking.www.demo.Student;
 ​
 public class Application {
     public static void main(String[] args) {
         Student student = new Student();
         student.test1("Dragon");
         System.out.println("=================");
         student.test2();
     }
 }

super注意点

1. super 调用父类的构造方法，必须在构造方法的第一个

2. super 必须只能出现在子类的方法或者构造方法中

3. super 和 this 不能同时调用构造方法！

Vs this

• 代表对象不同

  • this -- 本身调用者这个对象

  • super -- 代表父类对象的引用

• 前提

  • this -- 没有继承也可以使用

  • super -- 只能在继承的条件使用

• 构造方法

  • this() -- 本类的构造

  • super() -- 父类的构造！