5.2~5.8学习情况

一、封装与隐藏

面向对象的特征一:

封装与隐藏

一问题的引入:

当我们创建一个类的对象以后，我们可以通过""对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。但是除此之外，没有其他制约条件。

但是，在实际问题中，我们往往需要给属性赋值，加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如: setLegs (int n))

同时，我们需要避免用户再使用“对象.属性"的方式对属性进行赋值，则需要将属性声明为私有的（private)

-->此时，针对属性就体现了封装性

二、封装性的体现:

我们将类的属性xxx私有化(private)，同时，提供公共的(public)方法来获取(getXxx）和设置(setXxx）此属性的值

拓展﹔封装性的体现:①如上②不对外暴露的私有方法③单例模式...

三、封装性的体现，需要权限修饰符来配合。

1.Java规定的4种权限:(从小到大排列）: private、缺省、protected、public

2.四种权限可以用来修饰类及类的内部结构:属性、方法、构造器、内部类

3.具体的，四种权限都可以用来修饰类的内部结构:属性、方法、构造器、内部类

修饰类的话，只能使用缺省、public

总结封装性:Java提供了4中权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小

类的结构之三:构造器（或构造方法、constructor）的使用constructor:建设、建造。

1、构造器的作用:

①.创建对象

②初始化对象信息

2、说明:

①.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器

②.定义构造器的格式:权限修饰符类名〔形参列表）(

③.一个类中定义的多个构造器，彼此构成重载

④一旦我们显示的定义了类的构造器之后，系统就不在提供默认的空参构造器

⑤.一个类中，至少会有一个构造器

总结：属性赋值的先后顺序

• 默认初始化
• 显示初始化
• 构造器中初始化
• 通过“对象.方法  或 ”对象.属性“的方式赋值

以上操作的先后顺序：① ——②——③——④

拓展知识：JavaBean

JavaBean是一种Java语言写成的课重用 组件。

所谓JavaBean，是指符合如下标准的Java类：

>类是公共的

>有一个无参的公共构造器

>有属性，且有对应的get、set方法

关键字this 的使用：

this关键字的使用:

1.this可以用来修饰:属性、方法、构造器

2.this修饰属性和方法

this理解为:当前对象

2.1在类的方法中，我们可以使用"this .属性"或"this.方法”的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显示的使用“this.变量”的方式，表明此变量是属性，而非形参。

2.2在类的方法中，我们可以使用“this .属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略"this ."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显示的使用"this.变量”的方式，表明此变量是属性，而非形参。

关键字package、import的使用：

• package关键字的使用

1. 为了更好的实现项目中类的管理，提供包的概念
2. 使用packeage声明类或者接口所属的包，声明在源文件的首行
3. 包，属于标识符，遵循标识符的命名规则、规范（xxxyyyyzzzz）、“见名知意“
4. 每“.“一次，就代表每一层文件目录

  

补充：同一个包下，不能命名同名的接口、类。

           不同的包下，可以命名同名的接口、类。

• Import关键字的使用：

Import：导入

1. 在源文件中显式的使用import结构导入指定包下的类、接口
2. 声明在包的声明和类的声明之间
3. 如果需要导入多个结构，则并列写出即可
4. 可以使用“xxx.*“的方式，表示可以导入xxx包下所有的结构
5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
6. 如果使用的类或接口是本包下定义的，则可以省略import结构
7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方法显示

1. 使用“xxx.*“方式表明可以调用xxx包下的所有结构。但是如果是使用的是xxx下的子包，则仍需现实导入
2. import  static：导入指定类或接口中的静态结构：属性或方法

 

 

二、继承性

• 继承性的好处：
  • 减少了代码的冗余，提高了代码的复用性
  • 便于拓展功能
  • 为了之后多态性的使用，提供了前提

继承性的格式：class  A  extends B {  }

A：子类、派生类、subclass 

B：父类、超类、基类、superclass

2.1体现：一旦子类A继承父类B以后，子类A就获取了父类B中声明的所有的属性和方法。

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已。

2.2子类继承父类以后，还可以定义自己的属性和方法。实现功能的拓展

子类和父类的关系，不同于子集和集合的关系。

• 继承性的规定：

1. 一个类可以被多个子类继承
2. Java中类的单继承性：一个类只能有一个父类
3. 子父类是相对的概念
4. 子类直接继承父类，成为：直接父类。间接继承的父类成为：间接父类
5. 子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

举例：

 

四、1.如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类

2.所有的类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类

3.意味着，所有的java类具有java.lang.Object类声明的功能

方法的重写

1. 重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
2. 应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的时子类重写父类的方法
3. 重写的规定：

     方法的声明：权限修饰符  返回值类型  方法名（形参列表）throws  异常类型{

           //方法体

        }

     约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

• • 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
  • 子类重写的方法的权限修饰符不小于父类的方法权限修饰符

>特殊情况：子类不能重写父类中声明为private权限的方法

③返回值类型：

      >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void

      >父类被重写的方法的返回值类型是A类，则子类重写的返回值类型可以是A类或者A类的子类

      >父类被重写的方法的返回值类型是基本数据类型（比如：double），则子类重写的返回值类型必须是相同的基本数据类型（也必须是double）

④子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不重写）。

super关键字的使用

1. super理解为：父类的
2. super可以用来调用：属性、方法、构造器
3. super的使用

3.1我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略“super.”

32特殊情况下：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则则必须显式的使用“super.”的方式，来表明调用的是父类中声明的属性

3.3特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用“super.”的方式，来表明调用的是父类中被重写的方法

1. super调用构造器

4.1我们可以在子类的构造器中显式的使用“super（形参列表）”的方式，调用父类中声明的指定的构造器。

4.2“super（形参列表）”的使用，必须声明在子类构造器的首行

4.3我们在类的构造器中，针对与“this（形参列表）”或“super（形参列表）”只能二选一，不能同时存在

4.4 在构造器的首行，没有显式的声明“this（形参列表）”或“super（形参列表）”，则默认调用的时父类中空参的构造器，super（）

三、所作的练习题：

1.

package com.atguigu.exer4;

public interface Usb {
     void connect();
}

package com.atguigu.exer4;

public class UDisk implements Usb{
    private String brand;
    public UDisk(String brand){
        super();
        this.brand = brand;
    }
    public void connect(){
        System.out.println("已连接U盘器"+this.brand+",正在读取数据...");
    }
}

package com.atguigu.exer4;

public class Charger implements Usb {
    private String brand;
    public Charger(String brand){
        super();
        this.brand = brand;
    }
    public void connect(){
        System.out.println("已连接充电器"+this.brand+",正在充电");
    }

}

package com.atguigu.exer4;

public class Computer {
    private String brand;
    public Computer(String brand){
        super();
        this.brand = brand;
    }
    public void insertUsb(Usb device){
        System.out.println(this.brand);
        device.connect();
    }
}

package com.atguigu.exer4;

public class Mobile {
    private String brand;
    public Mobile(String brand){
        super();
        this.brand = brand;
    }
    public void insertUsb(Usb device){
        System.out.println(this.brand);
        device.connect();
    }
}

package com.atguigu.exer4;
public class UsbTest {

    public static void main(String[] args) {

        Mobile A=new Mobile("xiaomi");
        Charger B= new Charger("小米CDQ012M");
        Computer C=new Computer("联想");
        UDisk D=new UDisk("kingston");
        A.insertUsb(B);
        C.insertUsb(D);
    }
}

2.银行练习题：

package com.atguigu.exer3;
public class Account {
    private double balance;
    public Account(double init_balacne){
        this.balance = init_balacne;
    }
    public double getBalance() {
        return balance;
    }
    //存钱
    public void deposit(double amt){
        if(amt>0){
            balance += amt;
            System.out.println("存钱成功！");
        }
    }
    //取钱
    public void withdraw(double amt){
        if(balance>=amt){
            balance -= amt;
            System.out.println("取钱成功！");
        }else {
            System.out.println("余额不足，取钱失败！");
        }
    }
}

package com.atguigu.exer3;

public class Bank {
    private Customer[] customers;//存放多个客户的数组
    private int numberOfCustomers;//记录客户的个数
    public Bank(){
        customers = new Customer[10];
    }
    //添加客户
    public void addCustomer(String f,String l){
        Customer cust = new Customer(f,l);
        customers[numberOfCustomers] = cust;
        numberOfCustomers++;
    }
    //获取客户的个数
    public int getNumberOfCustomers(){

        return numberOfCustomers;
    }
    //获取指定位置上的客户
    public Customer getCustomer(int index){
        //return customer[index]  可能报异常
        if(index >= 0 && index <numberOfCustomers ){
            return customers[index];
        }
        return null;
    }
}

package com.atguigu.exer3;

public class Customer {
    private String firstName;
    private String lastName;
    private Account account;
    public Customer(String firstName,String lastName){
        this.firstName = firstName;
        this.lastName  = lastName;
    }
    public Account getAccount() {
        return account;
    }
    public void setAccount(Account account) {
        this.account = account;
    }
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }

}

package com.atguigu.exer3;

public class BankTest {
    public static void main(String[] args) {
        Bank bank = new Bank();
        bank.addCustomer("Jane","Smith");
        bank.getCustomer(0).setAccount(new Account(2000));
        bank.getCustomer(0).getAccount().withdraw(500);
        double balance = bank.getCustomer(0).getAccount().getBalance();
        System.out.println("客户："+bank.getCustomer(0).getFirstName()
                +"的账户余额为："+balance);
        System.out.println("*********************************");
        bank.addCustomer("万里","杨");
        System.out.println("银行客户的个数："+bank.getNumberOfCustomers());
    }
}
四、在力扣上做的两道题