从零开始学JAVA（05）：面向对象编程--01

一、class类

• 是用来描述一类事物的
• 可以在把内部定义任何数量的、不同类型的变量，作为这一类事物的属性。这种属性叫做成员变量
• 有类名，类名必须和文件名一样
• 就好像文件路径+文件名不能重复一样，一个java程序中相同名字的类只能有一个
• 从数据类型的角度来看，类就是自己创建了一种新的数据类型。类也叫做
  “ 自定义类型 ”。一个Java程序中不允许类同名。

 1、创建一个类

// 一个类以 public class 开头，public class代表这个类是公共类，类名必须和文件名相同
public class Student {
    // 类体中可以定义描述这个类的属性的变量，称之为 成员变量
    String name;
    String id;
    int ranking;
    double grade;
}

2、使用类

• 使用new操作符可以创建某个类的一个实例，在java程序运行的时候，所有这些创建出来的实例都被java放在内存里一个叫做堆的地方 
• 通过点操作符，给类的某个成员变量赋值

public class School {
    public static void main(String[] args) {
 
        // 创建一个Student实例，用xiaoming指向它
        Student xiaoming = new Student();
        // 使用点操作符，给xiaoming指向的实例（对象）赋值
        xiaoming.name = "小明";
        xiaoming.id = "1";
        xiaoming.grade = 82.5;
        xiaoming.ranking = 10;
 
        Student xiaoHua = new Student();
        xiaoHua.name = "小华";
        xiaoHua.id = "2";
        xiaoHua.grade = 87.0;
        xiaoHua.ranking = 8;
    }
}

二、引用数据类型

Java中的数据类型分为基本数据类型和引用数据类型

引用里边实际上存放的是一个地址

1、示例 

public class School {
    public static void main(String[] args) {
 
        // 创建一个Student实例，用xiaoming指向它
        // xiaoming 是一个Student类型的引用，只能指向Student类型的实例
        // 引用数据类型变量包含两部分信息：类型和实例
        // 每一个引用数据类型的变量，都是指向某个类的一个实例，不同类型的引用在java里都是引用
        // 引用的类型信息在创建时就已经确定，可以通过给引用赋值，让其指向不同的实例
        // xiaoming 就是 Student类型，只能指向Student的实例
        // 给一个引用赋值，则两者的类型必须一样
        Student xiaoming = new Student();
        // 使用点操作符，给xiaoming指向的实例（对象）赋值
        xiaoming.name = "小明";
        xiaoming.id = "1";
        xiaoming.grade = 82.5;
        xiaoming.ranking = 10;
 
        Student xiaoHua = new Student();
        xiaoHua.name = "小华";
        xiaoHua.id = "2";
        xiaoHua.grade = 87.0;
        xiaoHua.ranking = 8;
    }
}

2、引用数据类型和基本数据类型

 （1）相同点

• 都可以用来创建变量，可以赋值和使用值
• 本身就是一个地址

（2）不同点

• 基本数据类型变量的值，就是地址对应的值。引用数据类型的值还是一个地址，需要通过“二级跳”找到实例

  System.out.println(xiaoming); // Student@6b71769e
  

• 引用数据类型是java的一种内部类型，是对所有自定义类型和数组引用的统称，并非特指某种类型

三、类、对象和引用的关系

1、类和对象的关系

• 类是对象的模板，对象是类的一个实例
• 一个java程序中类名相同的类只能有一个，也就是类型不会重名
• 一个类可以有很多对象
• 一个对象只能根据一个类来创建

2、引用和类以及对象的关系

• 引用必须、只能是一个类的引用
• 引用只能指向其所属的类型的类的对象
• 相同类型的引用之间可以赋值
• 只能通过指向一个对象的引用，来操作一个对象，比如访问某个成员变量

四、重识数组

数组是一种特殊的类

• 数组的类名就是类型带上小括号
• 同一类型的数组，每个数组对象的大小可以不一样。也就是每个数组对象占用的内存可以不一样，这点和类的对象不同。
• 可以用引用指向类型相同大小不同的数组，因为它们属于同一种类型

引用的数组

• 可以把类名当成自定义类型，定义引用的数组，甚至多维数组

• 数组变量其背后真身就是引用，数组类型就是一种特殊的类 
• 数组的大小不决定数组的类型，数组的类型是只由元素类型决定的

五、引用的缺省值：null

• null是引用类型的缺省值
• null 代表空，不存在
• 引用类型的数组创建出来，初始值都是null
• NullPointerException
• 如果不确定，使用前需要先判断引用是不是空

public class ArrayTest {
    public static void main(String[] args) {
        Student[] students = new Student[10];
        for (int i = 0; i < students.length; i++) {
            if (i % 2 == 0) {
                students[i] = new Student();
            }
        }
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
            //  System.out.println(students[i].grade); // 报错Exception in thread "main" java.lang.NullPointerException
            if (students[i] != null) {
                System.out.println(students[i].grade);
            }
        }
    }
}

 六、像自定义类型一样使用类(随意组合)

类就是一种自定义类型

• 在类定义中可以使用类，创建类的引用
• 在类定义中，甚至可以使用类自己的类创建应用
• 引用类型的缺省值是null，一个类定义中如果有引用，创建出来的实例，其缺省值是null

public class MyPhone {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.hasFigurePrintUnlocker = true;
        phone.price = 1999;
        phone.screen = new Screen();
 
        phone.screen.producer = "京北方";
        phone.screent.size = 8.8;
 
        CPU cpu = new CPU();
 
        cpu.producer = "三星";
        cpu.speed = 3.5;
 
        Memory memory = new Memory();
        memory.producer = "三星";
        memory.capacity = 4;
 
        Storage storage = new Storage();
        storage.producer = "Intel";
        storage.capacity = 128;
 
        phone.mainboard = new Mainboard();
 
        phone.mainboard.ccpu = cpu;
        phone.mainboard.memory = memory;
        phone.mainboard.storage = storage;
        phone.mainboard.model = "EA888";
        phone.mainboard.year = "2022";
    }
 
}

七、Java中的包和访问修饰符

1、包 

• 为了避免类在一起混乱，可以把类放在文件夹里。这时就需要硬package语句告诉Java这个类在哪个package里。package语句要和源文件的目录完全对应，大小写一致
• 一般来说，类都会在包里，而不是直接放在根目录
• 不同的包里可以有相同的类
• 一个类只能有一个package语句，如果有package语句，则必须是类的第一行有效代码
• 包名+类名 = 类的全限定名。简称为类的全名
• 同一个Java程序中全限定名字不可重复

package com.phone.parts;
import com.phone.Phone;
public class MyPhone {
    public static void main(String[] args) {
        Phone myPhone = new Phone();
        myPhone.name = "123";
    }
}

 2、访问修饰符public

• 被 public（访问不受限制，是权限最多的一个修饰符）修饰的属性，可以在任意包中的类去访问
• 没有访问修饰符的属性，称作缺省的访问修饰符，可以被本包内的其他类和自己的对象访问
• 访问修饰符是一种限制或者允许属性访问的修饰符