Java面向对象：封装——类与对象

====================================================================================

1.类与对象的介绍与定义

• 类与对象是面向对象程序设计中的核心编程；
• 世间万物或具体或抽象；皆可对象；需要定义好对象的属性和行为；以此可以完成某件事；对象与引用介绍 跳转链接
• 类：类是自定义的数据类型，实例化出来的变量我们成为对象；类是用来对一些实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)；
• 使用class关键字来定义类：

// 创建类
class ClassName{
 field; // 字段(属性) 或者 成员变量
 method（）; // 行为 或者 成员方法
}

• 类名注意采用大驼峰定义

1. 一个.java文件当中可以定义多个类，但必须有一个以public修饰的类；
2. main方法所在的类必须要使用public修饰
3. public修饰的类必须要和文件名相同
4. new 关键字用于创建一个对象的实例.
5. 使用 . 来访问对象中的属性和方法.
6. 同一个类可以创建多个实例.

例：
// 在同一个包中创建的类，都可以被一个主类的主方法调用；（下例中，在Dog类中定义的该对象属性、行为；在ClassPractice类中主类的主函数中进行Dog对象实例化，进而初始化和调用方法）

package objectClass;

/**
 * @Author: 19261
 * @Date: 2021/9/3 17:07
 */
//通过创建特定的类，表示实际的对象特征；
public class Dog {
    //属性
    public String name; //属性1：名字
    public int age;     //属性2：年龄
    public String breed;//属性3：品种

    //方法/行为
    public void eat(){
        System.out.println(name+"正在吃饭!");
    }
    public void play(){
        System.out.println(name+"正在玩耍！");
    }
    public void introduce(){
        System.out.println(name+"是"+breed+"品种,"+"今年"+age+"岁了！");
    }
}

package objectClass;

/**
 * @Author: 19261
 * @Date: 2021/9/1 19:34
 */
public class ClassPractice {
    public static void main(String[] args) {
        //对象实例化
        //对象属性初始化：通过 . 解引用操作
        //方法行为的调用：通过 . 调用该对象封装类的方法，完成某种行为
        Dog dog1=new Dog();
        dog1.name="小呆";
        dog1.age=1;
        dog1.breed="金毛";

        Dog dog2=new Dog();
        dog2.name="旺财";
        dog2.age=2;
        dog2.breed="吉娃娃";

        Dog dog3=new Dog();
        dog3.name="迪加";
        dog3.age=1;
        dog3.breed="边牧";

        dog1.introduce();
        dog2.introduce();
        dog3.introduce();
        dog1.eat();
        dog2.play();
        dog3.play();
    }
}

2.类成员初始化

（1）默认初始化

// 默认初始化： 只要创建了类对象，Java中都会先把对象成员自动设置为默认值；

• 数字类型（包括整数和浮点数）默认值为0；
• 布尔类型默认为false；
• 引用类型默认为null；

public class Test {
    public byte a;
    public short b;
    public char c;
    public int d;
    public long e;
    public double f;
    public boolean l;
    public String s;
    public int[] arr;
}

public class ClassPractice {
    public static void main(String[] args) {
        Test t=new Test();
        System.out.println(t.a);
        System.out.println(t.b);
        System.out.println(t.c);
        System.out.println(t.d);
        System.out.println(t.e);
        System.out.println(t.f);
        System.out.println(t.l);
        System.out.println(t.s);
        System.out.println(t.arr);
	}
}

（2）构造方法对类字段初始化

• 类对象的构造方法必须与类名相同；
• 若类中已经定义了有参构造方法，则不在生成无参构造的对象；
• 类中的构造方法没有return返回值，默认返回对象本身；
• 构造方法支持重载（通过参数个数和类型的不同实现重载）
• 构造方法不需要显式调用，在类对象通过new关键字创建时 自动调用执行；

class Student{
    //成员/属性
    public String name;
    public int age;
    //构造方法
    public Student(){
        name="小明";
        age=18;
    }
    public Student(int a){
        age=a;
    }
    public Student(String n){
        name=n;
    }
    public Student(String n,int a){
        name=n;
        age=a;
    }
    public void show(){
        System.out.println(name+" "+age);
    }
}

public class ClassPractice {
    public static void main(String[] args) {
        //对象实例化
        //对象属性初始化：通过 . 解引用操作
        //方法行为的调用：通过 . 调用该对象封装类的方法，完成某种行为
        Student s1=new Student();
        s1.show();
        Student s2=new Student("小红");
        s2.show();
        Student s3=new Student(2);
        s3.show();
        Student s4=new Student("小白",19);
        s4.show();
    }
}       

// 创建对象时，通过 new() 调用实现自动调用构造方法初始化；
// 在创建对象时，先默认初始化；然后再通过构造方法初始化；没有通过构造方法初始化的成员属性，仍保留默认值；

（3）this 的使用与代码块初始化

• this 表示当前对象本身的引用；
• this 在成员方法中，只能只想该对象，不能再指向别的对象，具有final属性；
• 可以通过this 调用自身的构造方法；
• this 只能在成员方法中使用，必须放在第一行，第一个使用；
• 使用场景：当形参与成员名相同时，必须加以区分，使用this . 属性 ——表示指向对象本身；
• java编译器给每个“成员方法“增加了一个隐藏的引用类型参数，该引用参数指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中中所有成员变量的操作，都是通过该引用去访问。

// 代码块相当于无参的构造方法；并且构造方法后执行于代码块；

public class Point {
    public int x;
    public int y;
    //相当于没有参数的构造方法，也是在new 创建对象时自动调用
    {
        x=0;
        y=1;
    }
    //构造方法在默认初始化和代码块初始化之后执行的初始化
    public Point(int x,int y){
        //当形参和类成员属性名字相同时，使用Java中的this 指向对象的该属性
        this.x=x;
        // 通过this调用它自身构造方法
        //this(x);
        this.y=y;
    }
    public void show(){
        System.out.println("点("+x+","+y+")");
    }
}

public class ClassPractice {
    public static void main(String[] args) {
        Point p=new Point(1,2);
        p.show();
    }
}

• // 在IDEA 中可以自动生成构造方法：
  Alt+Insert ->Constructor -> 选择属性 ->点击ok 完成创建；
  

3.类成员函数 toString的使用

• 每一个类中都可以创建一个toString()方法 用于查看所创建对象的属性；
• 调用自己创建的toString()方法：System.out.println(对象名）/ 对象名 . toString();
• IDEA 中可以自动生成toString()方法：Alt+Insert ->toString() -> 选择全部属性 ->点击ok 完成创建；
  

• 自动生成的toString()方法 使用的时候直接 利用输出语句调用System.out.println(对象名）；

//    public String toString(){
//        return "点("+this.x+","+this.y+")";
//    }
    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

5.包与全限定类名

• 包：：为了更好的管理类，把多个类或者收集在一起成为一组，称为软件包。
• 包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，
• 在同一个工程中允许存在相同名称的类，只要处在不同的包中即可；
• // 自定义包 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包；
  
• 编写代码时，需要创建隶属于别的包（自定义/Java系统包）的对象，需要将类导入包中：
  • 1.通过全限定类名创建：java.util.Data data=new Data();
  • 2.通过使用 import语句导入包.import java.util.Data;
    // import java.util.*;表示导入Java类工具包util中的所有类；

// 常见的Java包：

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
2. java.lang.reflect:java 反射编程包;
3. java.net:进行网络编程开发包。
4. java.sql:进行数据库开发的支持包。
5. java.util:是java提供的工具程序包。(集合类等) 非常重要
6. java.io:I/O编程开发包。

6.static修饰与public、private修饰

（1）static的使用

• 在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。
• static 的使用：
  • 被static修饰的成员或属性，是类的属性/成员/字段，可以通过 对象.属性 访问，但一般通过 类名.属性访问；
    • 类的成员的生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)。JDK7及以前，HotSpot(Java虚拟机)中存储在方法区，JDK8及之后，类变量存储在Java堆中；
  • 被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的（类名 . 成员方法）。
    • 静态方法没有隐藏的this引用参数，因此不能在静态方法中访问任何非静态成员变量
    • 可以在非静态方法中调用静态成员方法；
      

public class Computer{
    public int id;
    private static String cpu;
    public String memory;

    public Computer() {
        id=123;
        cpu="MAR";
        memory="100G";
    }
    public void show(){
        System.out.println(id);
        //可以在非静态方法中调用静态成员方法
        this.replace("MMM");
    }
    public static void replace(String s){
        //this.id=n;
        cpu=s;
        System.out.println(cpu);
    }

    @Override
    public String toString() {
        return "Computer{" +
                "id=" + id +
                ", memory='" + memory + '\'' +
                ", cpu='" + cpu + '\''+
                '}';
    }
}

public class ClassPractice {
    public static void main(String[] args) {
        Computer c=new Computer();
        System.out.println(c);
        c.show();
        Computer.replace("max");
    }
}

• 实例代码块与static代码块：

    //实例代码块
    {
        this.id=333;
        this.memory="50G";
        this.cpu="MAR20";
        System.out.println("执行实例代码块");
    }
    //static代码块
    static{
        cpu="NULL";
        System.out.println("执行static代码块");
    }

// 通过代码运行结果可知：

• 由static修饰的静态代码块不管生成多少个对象，其只会执行一次静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的；
  

（2）访问限定符

• Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制那些方法或者属性需要在类外直接使用；
• // 表格中有三角符号表示该限定符修饰的可以访问；
  
  public：可以理解为一个人的外貌特征，谁都可以看得到
  default: 对于自己家族中不是什么秘密，对于其他人来说就是隐私了
  private：只有自己知道，其他人都不知道
• 访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

例：

7.Java面向对象之 封装

• 面相对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。
• **封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。**控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。
• 封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。