javaSE基础学习day09

面向对象的特征之一：封装与隐藏

程序设计追求“高内聚低耦合”，高内聚 (类的内部数据操作细节自己完成，不允许外部干涉)；低耦合(对外仅暴露少量的方法用于使用)。隐藏对象内部的复杂性，只对外公开简单的接口便于外界调用，从而提高系统的可扩展性和可维护性。把该隐藏的隐藏起来，该暴露的暴露出来，这就是封装性的设计思想。

当创建一个类的对象后，可以通过object.field给对象的属性赋值，赋值操作要受到属性的数据类型和存储范围的制约，除此之外没有其他的制约条件。但在实际问题中，往往需要给属性赋值加入额外的限制条件，这个条件不能在属性声明时体现，只能通过方法添加限制条件。为了避免用户再使用object.field的方式对属性赋值，则需要将属性声明为私有的(private)，此时针对属性就体现了封装性。

java中通过将数据声明为私有的(private)，再提供公共的(public)方法：getXxx()和setXxx()实现对该属性的操作，以实现下述目的：
📌 隐藏一个类中不需要对外提供的实现细节；
📌 使用者只能通过事先定制好的方法来访问数据；
📌 可以方便地加入控制逻辑，限制对属性的不合理操作；
📌 便于修改，增强代码的可维护性。

封装性思想具体的代码体现：
体现一：将类的属性xxx私化(private)，同时提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值；

public void setRadius(double radius){
	this.radius = radius;
}
public double getRadius(){
	return radius;
}

体现二：不对外暴露的私有的方法；
体现三：单例模式（将构造器私有化）；
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

权限修饰符

封装性的体现，需要权限修饰符来配合。权限修饰符（权限从小到大排列）private，缺省、protected、public置于类的成员定义前，用来限定对象对该类成员的访问权限。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
缺省	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

4种权限修饰符可以用来修饰类的内部结构（属性、方法、构造器、内部类、代码块<不可修饰>）

对于class的权限修饰只可以用public和default(缺省)。
📌 public类可以在任意地方被访问。
📌 default类只可以被同一个包内部的类访问。

练习1

//创建程序,在其中定义两个类：Person和PersonTest类。定义如下：用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。在 PersonTest 类 中 实 例 化 Person 类 的 对 象 p ，调 用 setAge()和getAge()方法，体会Java的封装性。
public class PersonTest {
    public static void main(String[] args){
        Person p = new Person();
        p.setAge(22);
        System.out.println(p.getAge());	
    }
}

public class Person {
    private int age;
    public void setAge(int i){
        if(i < 0 || i > 130){
            //throw new RuntimeException("传入的数据非法！");
            System.out.println("传入的数据非法！");
            return;
        }
        age = i;		
    }
    public int getAge(){
    	return age;
    }	
}

类的成员之三：构造器（构造方法）

构造方法(创建类的对象：new+构造器)是与类同名且没有返回值类型的方法，当创建类的对象(实例化类)时，就会自动调用构造方法。构造器的主要作用是创建对象或者初始化对象的信息(主要是属性)。

//构造器的语法格式
修饰符 类名(参数列表){
    初始化语句;
} 

//举例
public class Animal {
    private int legs;
    // 构造器
    public Animal() {
        legs = 4;//将legs初始化为4。
    } 
}

根据参数不同，构造器可以分为如下两类：
📌 隐式无参构造器（系统默认提供）
📌 显式定义一个或多个构造器（无参、有参）

注意：
📌 Java语言中，每个类都至少有一个构造器，一个类可以创建多个重载的构造器。
📌 默认构造器的修饰符与所属类的修饰符一致，父类的构造器不可被子类继承。
📌 如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器。
📌 一旦显式定义了构造器，则系统不再提供默认构造器。
📌 构造器不能被static、final、synchronized、abstract、native修饰，不能有return语句。

练习2

//编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
public class TriAngleTest{
    public static void main(String[] args){
        TriAngle t = new TriAngle();
        t.setNum(10,2.5);
        System.out.println("三角形的底边长是" + t.getBase + "，高是" + t.getHeight + "，面积是" + t.getArea);
        
        TriAngle t2 = new TriAngle(4,2.5);
        System.out.println("三角形的底边长是" + t.getBase + "，高是" + t.getHeight + "，面积是" + t.getArea);
    }
}

public class TriAngle{
    //属性
    private double base;
    private double height;
    //构造器
    public TriAngle(){
    }
    public Triangle(double b,double h){
        base = b;
        height = h;
    }
    //方法
    public void setNum(double b,double h){
        base = b;
        height= h;  
    }
    public double getBase(){
        return base;
    }
    public double getHeight(){
        return height;
    }
    public double getArea(){
        return base * height * 0.5;
    }
}

属性赋值过程

赋值的先后顺序：① - ② - ③ - ④
赋值的位置：
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过“object.field”或“object.method”的方式赋值

JavaBean

JavaBean是一种由Java语言写成的可重用组件，所谓javaBean，是指符合如下标准的Java类：
📌 类是公共的
📌 有一个公共的无参的构造器
📌 有属性，且有对应的get、set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

//示例
public class JavaBean {
    //属性
    private String name; // 属性一般定义为private
    private int age;
    //构造器
    public JavaBean() {
    }
    //方法
    public int getAge() {
        return age;
    }
    public void setAge(int a) {
        age = a;
    }
    public String getName() {
        return name;
    }
    public void setName(String n) {
        name = n;
    }
}

UML类图

uml图的六种箭头，注：+表示public类型，-表示private类型，#表示protected类型

this关键字

在java中，this关键字可以调用类的属性、方法和构造器，this可理解为当前对象（当前正在操作本方法的对象称为当前对象）或当前正在创建的对象。它在方法内部使用，即这个方法所属对象的引用；它在构造器内部使用，表示该构造器正在初始化的对象。

在任意方法或构造器内，如果使用当前类的成员变量或成员方法，可以在其前面添加this，增强程序的阅读性，不过通常都习惯省略this。当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须使用“this.field”来表明该变量是类的成员变量。使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。this可以作为一个类中构造器相互调用的特殊格式：

① 可以在类的构造器中使用“this(形参列表)”的方式，调用本类中重载的其他的构造器；
② 构造器中不能通过“this(形参列表)”的方式调用自身构造器；
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了“this(形参列表)”；
④ “this(形参列表)”必须声明在当前构造器的首行；
⑤ 在类的一个构造器中，最多只能声明一个“this(形参列表)”，用来调用其他的构造器。

练习3

按照如下的 UML 类图，创建相应的类，提供必要的结构，创建 BankTest 类进行测试，要求如下：

• 在提款方法withdraw()中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示，deposit()方法表示存款。
• addCustomer方法必须依照参数（姓，名）构造一个新的Customer对象，然后把它放到customer数组中。还必须把 numberOfCustomer属性的值加1。getNumOfCustomers方法返回numberofCustomer属性值。getCustomer方法返回与给出的 index参数相关的客户。

public class Account{
    //属性
    private double balance;
    //构造器
    public Account(double balance){
        this.balance = balance;
    }
    //方法
    public double getBalance(){
        return balance;
    }
    public void deposit(double amt){
        balance += amt;
        System.out.println("存款成功:" + amt);
    }
    public void withdraw(double amt){
        if(balance < amt){
            System.out.println("取款失败！");
            return;
        }
        balance -= amt;
        System.out.println("取款成功：" + amt);
    }  
}

public class Customer{
    //属性
    private String firstName;
    private String lastName;
    private Account account;
    //构造器
    public Customer(String f,String l){
        firstName = f;
        lastName = l;
    }
    //方法
    public String getFirstName(){
        return firstName;
    }
    public String getLastName(){
        return lastName;
    }
    public Account getAccount(){
        return account;
    }
    public void setAccount(Account acct){
        account  = acct;
    }
}

public class bank{
    //属性
    private Customer[] customers;
    private int numberOfCustomer;
    //构造器
    public Bank(){
        customers = new Customer[10];
    }
    //方法
    public void addCustomer(String f,String l){
        Arrays.fill(customers,new Customer(f,l));
        numberOfCustomer++;
    }
    public int getNumOfCustomers(){
        return numberOfCustomer;
    }
    public Customer getCustomer(int index){
        if(index >=0 && index < numberOfCustomer){
            return customers[index];
        }
        return null;
    }
}

public class BankTest{
    public static void main(String[] args){
        Bank bank = new Bank();
        bank.addCustomer("Jame","Smith");
        bank.getCustomer(numberOfCustomer - 1).setAccount(new Account(2000));
        bank.getCustomer(numberOfCustomer - 1).getAccount().deposit(100);
        bank.getCustomer(numberOfCustomer - 1).getAccount().withdraw(200);
        bank.getCustomer(numberOfCustomer - 1).getAccount().withdraw(3000);
        double balance = bank.getCustomer(numberOfCustomer - 1).getAccount().getBalance()
        System.out.println("客户" + bank.getCustomer(numberOfCustomer - 1).getFirstName() + bank.getCustomer(numberOfCustomer - 1).getLastName() + "的余额是：" + balance);
        
        bank.addCustomer("Fall","Gays");
        System.out.println("银行客户的人数是：" + bank.getNumOfCustomers());  
    }
}

package关键字

为了更好的实现项目中类的管理，java提出了包的概念。package语句作为java源文件的第一条语句，指明该文件中定义的类或接口所在的包(若缺省该语句，则指定为无名包)。

• 包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
• 同一个包下，不能命名同名的接口、类；不同的包下，可以命名同名的接口、类；
• 包通常用小写单词标识(xxxyyyzzz)，通常使用所在公司域名的倒置：com.atguigu.xxx。

//package的语法格式：package 顶层包名.子包名;
//举例：pack1\pack2\PackageTest.java
package pack1.pack2;    //指定类PackageTest属于包pack1.pack2
public class PackageTest{
    public void display(){
        System.out.println("in method display()");
    }
}

包的作用：
📌 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式；
📌 包可以包含类和子包，划分项目层次，便于管理。解决类命名冲突的问题，控制访问权限。
例：某航运软件系统包括：一组域对象、GUI和reports子系统

MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层(model)，控制器层(controller)，与数据模型层(view)。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

模型层 model 主要处理数据
>数据对象封装 model.bean/domain >数据库操作类 model.dao >数据库 model.db
控制层 controller 处理业务逻辑
>应用界面相关 controller.activity >存放fragment controller.fragment >显示列表的适配器 controller.adapter >服务相关的 controller.service >抽取的基类 controller.base
视图层 view 显示数据
>相关工具类 view.utils >自定义view view.ui

JDK中主要的包介绍
1. java.lang ——包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能。
2. java.net ——包含执行与网络相关的操作的类和接口。
3. java.io ——包含能提供多种输入/输出功能的类。
4. java.util ——包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5. java.text ——包含了一些java格式化相关的类。
6. java.sql ——包含了java进行JDBC数据库编程的相关类/接口。
7. java.awt ——包含了构成抽象窗口工具集（abstract window toolkits）的多个类，                               这些类被用来构建和管理应用程序的图形用户界面(GUI)。

import关键字

为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)，import语句会告诉编译器到哪里去寻找类。

//import的语法格式：import  包名.类名;
//举例：import pack1.pack2.*;表示引入pack1.pack2包中的所有结构
import  pack1.pack2.Test;
public class PackTest{
    public static void main(String args[]){
        Test t = new Test();   //Test类在pack1.pack2包中定义
        t.display();
    }
}

📌 在源文件中显式的使用import结构导入指定包下的类或接口；
📌 声明在包的声明和类的声明之间；
📌 如果需要导入多个类或接口，那么就并列显式多个import语句即可；
📌 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口；
📌 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句；
📌 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类；
📌 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入；
📌 import static：导入指定类或接口中的静态结构（属性或方法）。