JavaSE第六章、面向对象（下）

JavaSE第六章、面向对象（下）

一、包

1.概念

三大作用

1.区分相同名字的类；

2.类很多时，可以很好地管理类；

3.控制访问范围。

基本语法：package com.abc;

1.package:关键字；

2.com.abc:包名。

包的本质：是创建不同的文件夹来保存类文件。

2.包的命名

规则：只包含数字、字母、下划线、小圆点。不能以数字开头。不能是关键字或保留字。

规范：小写字母+小圆点。一般为：com.公司名.项目名.业务模块名。

3.使用

package com.use;

import com.xiaoqiang.dog;

public class Test {
    public static void main(String[] args) {
        dog doggy = new dog();
        System.out.println(doggy);

        com.xiaoming.dog doggy2 = new com.xiaoming.dog();	//未被引入的包需要带完整包名
        System.out.println(doggy2);
    }
}

package com.xiaoming;

public class dog {
}

package com.xiaoqiang;

public class dog {
}

包的导入

import java.util.Scanner;   //引入包下Scanner类
import java.util.*; //引入包下所有类

建议只导入需要的类。

注意事项：

1.package的作用是声明当前类所在的包，要放到类的最上面。一个类中最多只有一句package。

2.import指令放在package下面，在类定义前面。可以有多句且没顺序要求。

———————————————————————————

二、访问修饰符

public:对外公开。

private：只有本类可以访问。

protected：对子类和同一个包中的类公开。

默认：没有修饰符号，向同一个包的类公开。

注意事项：

1.修饰符可以用来修饰类中的属性，成员方法以及类。

2.只有默认的和public才能修饰类。

3.成员方法的访问规则和属性一样。

三、🚩封装&继承&多态

面向对象三大特征：封装、继承、多态

1.封装

定义：把抽象出的数据（属性）和对数据的操作（方法）封装在一起。数据被保护在内部，程序的其他部分要通过被授权的操作（方法）才能对数据进行操作。

好处：

1.隐藏实现细节：方法（连接数据库）<--调用（传入参数…）

2.可以对数据进行验证，保证安全合理。

实现：

• 将属性私有化（private）；

• 提供一个公共（public）的set方案，用于对属性判断并赋值；

  public void setXXX(类型 参数名）{

  ​ //加入数据验证的业务逻辑

  ​ 属性=参数名

  }

• 提供一个公共（public）的get方法，用于获取属性的值。

  public 数据类型 getXXX（）{

  ​ return xx；

  }

  快捷键：alt+insert或fn+alt+insert

一个简单的例子

package com.use;

public class Test{
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setAge(30);
        p1.setName("Mary");
        p1.setSalary(20000);
        System.out.println(p1.info());

        Person p2 = new Person("Jack",20,10000);
        System.out.println(p2.info());
    }
}

class Person{
    public String name;
    private int age;
    private double salary;

    public Person(){
    }
    public Person(String name,int age,double salary){
        this.name=name;
        this.age=18;
        this.salary=20000;
    }

    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;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String info(){
        return "信息为"+name+" "+age+" "+salary;
    }
}

2.继承

解决代码复用性的问题。

基本语法：class 子类 extends 父类{

}

• 子类会拥有父类定义的属性和方法
• 父类又叫超类、基类
• 子类又叫派生类

注意事项：

1.私有属性和方法不能在子类直接访问，要通过公共的方法去访问。

2.子类必须调用父类的构造器，完成父类的初始化。

3.创建子类对象时，不管使用子类哪个构造器，默认情况下总会调用父类的无参构造器。

4.如果父类没有提供无参构造器，则必须在子类的构造器中用super（参数列表）去指定使用父类的哪个构造器完成对父类的初始化工作。

5.super在使用时，要在构造器第一行。super（）和this（）都只能放在构造器第一行，因此这两个方法不能共存在同一构造器。

6.父类构造器的调用不限于直接父类（可向上追溯直到Object类）。

7.Java是单继承机制：子类最多直接继承一个父类。

❗继承的本质

一个例子

public class extend01 {
    public static void main(String[] args) {
        B b =new B();
        /*输出：
        a
        b name
        b*/
    }
}

class A{
    A(){
        System.out.println("a");
    }
    A(String name){
        System.out.println("a name");
    }
}
class B extends A{
    B(){
        this("abc");    //调用本类中另一种形成的构造函数(应该为构造函数中的第一条语句)
        System.out.println("b");
    }
    B(String name){
        System.out.println("b name");
    }
}

方法重写（覆盖）

子类有一个方法和父类的某个方法的名称、返回类型、参数一样，那么子类的这个方法就覆盖了父类的哪个方法。

3.多态

方法或对象具有多种形态。

具体体现：
1.方法的多态

2.⚠️对象的多态

• 一个对象的编译类型和运行类型可以不一致
• 编译类型在定义对象时就确定了，不能改变
• 运行类型是可以变化的
• 编译类型看定义时=号的左边，运行类型看“=”的右边

如：Animal animal = new Dog()；//animal的编译类型是Animal，运行类型是Dog

注意事项：

1.多态的前提：两个对象（类）存在继承关系

2.多态的向上转型

​ 多态可以调用父类中的所有成员（遵守访问权限），但不能调用子类的特有成员。

3.多态的向下转型

​ 语法：子类类型 引用名=（子类类型）父类引用；

​ 要求父类引用必须指向的是当前目标类型的对象。

4.instanceOf 比较操作符用于判断对象的类型是否为XX类型（或其子类型）

动态绑定机制：

1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。

2.当调用对象属性时，没有动态绑定机制。哪里声明，哪里使用。

多态应用：

• 多态数组

• 多态参数

四、Super

语法：

• 访问父类的属性（非private）：super.属性名；

• 访问父类的方法（非private）：super.方法名（参数列表）；

• 访问父类的构造器：super（参数列表）；

注意事项：

1.当子类中有和父类中的成员重名时，为了访问弗雷德成员，必须通过super。

2.super的访问不限于直接父类。如果多个基类中都有同名的成员，使用super访问遵循就近原则。

super与this的比较

五、Object类详解

1.**==和equals的对比 **：

==是比较运算符

• 判断基本类型：值是否相等

• 判断引用类型：地址是否相等

equals是Object类中的方法只判断引用类型。

• 默认判断地址。
• 子类中往往重写该方法，用于判断内容是否相等。比如：Integer，String。

2.hashCode

• 两个引用，如果指向的是同一个对象，哈希值一定一样；如果指向的是不同对象，哈希值不一样。
• 哈希值根据地址号（映射），不等于地址号。

3.toString

• 默认返回：全类名+@+哈希值的十六进制

• 子类往往重写toString方法，用于返回对象的属性信息

4.finalize