day11_封装丶构造器(构造方法)丶JavaBean丶this丶package 丶import

封装

为什么需要封装？封装的作用和含义？

我们程序设计追求“高内聚，低耦合”。

• 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
• 低耦合 ：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提 高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露 的暴露出来。这就是封装性的设计思想。使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。

查看下面代码

package com.atguigu.java;

/*
 * 面向对象的特征一：封装与隐藏     3W:what? why? how?
 * 一、问题的引入：
 *  当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到
 *  属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值
 *  加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
 *  同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
 *  -->此时，针对于属性就体现了封装性。
 *
 * 二、封装性的体现：
 * 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
 *
 *  拓展：封装性的体现：① 如上  ② 不对外暴露的私有的方法  ③ 单例模式   ...
 *
 *
 * 三、封装性的体现，需要权限修饰符来配合。
 * 1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
 * 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
 * 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
 *        修饰类的话，只能使用：缺省、public
 *
 * 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
 *
 */
public class AnimalTest {
    public static void main(String[] args) {
        //创建动物类的对象
        Animal a = new Animal();
        //直接操作属性赋值
        a.name = "小黄";
        //给动物的腿赋值为负数，是不符合实际情况的。
        a.legs = -1;

    }
}

//定义动物类
class Animal {

    String name;
    public int age;
    //腿的个数
    public int legs;


}

信息的封装和隐藏

Java 中通过将数据声明为私有的 (private) ，再提供公共的（ public ） 方法: getXxx() 和 setXxx() 实现对该属性的操作，以实现下述目的：

• 隐藏一个类中不需要对外提供的实现细节；
• 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑， 限制对属性的不合理操作；
• 便于修改，增强代码的可维护性；

修改上面的代码

public class AnimalTest {
    public static void main(String[] args) {
        //创建动物类的对象
        Animal a = new Animal();
        //直接操作属性赋值,，错误  a.name = "小黄";
        //给动物的腿赋值为负数，是不符合实际情况的。a.legs = -1;
        //通过方法赋值，我们可以在方法中写逻辑代码，排除错误的情况
        a.setAge(1);
        int age = a.getAge();
        System.out.print(age);//1
    }
}

//定义动物类
class Animal {

    private String name;
    private int age;
    //腿的个数
    private int legs;

    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 int getLegs() {
        return legs;
    }

    public void setLegs(int legs) {
        this.legs = legs;
    }
}

权限修饰符

封装性的体现，需要权限修饰符来配合。Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

       

Java规定的4种权限（从小到大排列）：private、缺省、protected 、public 

小结：

•  4种权限权限修饰符可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
•  修饰类的话，只能使用：缺省、public
• Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

封装的步骤

1. 使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。

构造器(构造方法)

构造器又可以叫做构造方法 或者constructor。construct：建设、建造。  construction:CCB    constructor:建设者

构造器的特征

• 它具有与类相同的名称
• 它不声明返回值类型。（与声明为void不同）
• 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用有下面2个：

• 创建对象
• 给对象进行初始化

语法格式：

修饰符 类名 ( 参数列表 ) {

            初始化语句；

       }

 

举 例：

扫描二维码关注公众号，回复： 10126660 查看本文章

package demo;

/*
 * 类的结构之三：构造器（或构造方法、constructor）的使用
 * construct：建设、建造。  construction:CCB    constructor:建设者
 *
 * 一、构造器的作用：
 * 1.创建对象
 * 2.初始化对象的信息
 *
 * 二、说明：
 * 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
 * 2.定义构造器的格式：权限修饰符  类名(形参列表){}
 * 3.一个类中定义的多个构造器，彼此构成重载
 * 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
 * 5.一个类中，至少会有一个构造器。
 */
public class PersonTest {
    public static void main(String[] args) {
        //创建类的对象:new + 构造器
        Person p = new Person();

        p.eat();

        Person p1 = new Person("Tom");

        System.out.println(p1.name);


    }
}

class Person {
    //属性
    String name;
    int age;

    //构造器
    public Person() {
        System.out.println("Person().....");
    }

    public Person(String n) {
        name = n;

    }

    //	
    public Person(String n, int a) {
        name = n;
        age = a;
    }


    //方法
    public void eat() {
        System.out.println("人吃饭");
    }

    public void study() {
        System.out.println("人可以学习");
    }

}

根据参数不同，构造器可以分为如下两类：

• 隐式无参构造器（系统默认提供）
• 显式定义一个或多个构造器（无参、有参）

注 意：

• Java语言中，每个类都至少有一个构造器
• 默认构造器的修饰符与所属类的修饰符一致
• 一旦显式定义了构造器，则系统不再提供默认构造器
• 一个类可以创建多个重载的构造器
• 父类的构造器不可被子类继承

练习题

/*
 * 编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。
 * 此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
 */
public class TriAngle { //angle:角    angel:天使
 
    private double base;//底边长
    private double height;//高
    //无参构造
    public TriAngle() {
 
    }
    //全参构造
    public TriAngle(double b, double h) {
        base = b;
        height = h;
    }
 
 
    public void setBase(double b) {
        base = b;
    }
 
    public double getBase() {
        return base;
    }
 
    public void setHeight(double h) {
        height = h;
    }
 
    public double getHeight() {
        return height;
    }
 
}

定义测试类 

 
 
public class TriAngleTest {
    public static void main(String[] args) {
        //使用无参构造创建对象
        TriAngle t1 = new TriAngle();
        t1.setBase(2.0);
        t1.setHeight(2.4);
        System.out.println("base : " + t1.getBase() + ",height : " + t1.getHeight());//base : 2.0,height : 2.4
 
        //使用全参构造创建对象
        TriAngle t2 = new TriAngle(5.1,5.6);
        System.out.println("base : " + t2.getBase() + ",height : " + t2.getHeight());//base : 5.1,height : 5.6
    }
}

构造器重载

• 构造器一般用来创建对象的同时初始化对象。如

                                         

• 构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。 构造器重载举例

                        

构造器重载，参数列表必须不同 

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

截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位 置，并指明赋值的先后顺序

•  ① 默认初始化
•  ② 显式初始化
•  ③ 构造器中初始化
•  ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值

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

JavaBean

JavaBean 是一种 Java 语言写成的可重用组件。 所谓javaBean ，是指符合如下标准的 Java 类：

• 类是公共的
• 有一个无参的公共的构造器
• 有属性，且有对应的get、set方法

作用：

• 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以 用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用 户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关 心任何改变

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类图

               

关键字this

this是什么？

• 它在方法内部使用，即这个方法所属对象的引用；
• 它在构造器内部使用，表示该构造器正在初始化的对象

作用：

• this 可以调用本类的属性、方法和构造器

用法也有三种：

• 在本类的成员方法中，访问本类的成员变量。格式：this.成员变量
• 在本类的成员方法中，访问本类的另一个成员方法。格式：this.成员方法名()
• 在本类的构造方法中，访问本类的另一个构造方法。格式：this(...)

使用this，调用属性、方法

• 在任意方法或构造器内，如果使用当前类的成员变量或成 员方法可以在其前面添加this， 增强程序的阅读性。
• 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
• 使用this访问属性和方法时， 如果在本类中未找到，会从父类中查找

// 定义Person类
class Person {
    private String name;
    private int age;
 
    public Person(String name, int age) {
        //this来表明该变量是类的成员变量
        this.name = name;
        this.age = age;
    }
 
    public void getInfo() {
        System.out.println("姓名：" + name);
        //访问成员方法,如果没有去父类找
        this.speak();
    }
 
    public void speak() {
        //this.age访问成员变量
        System.out.println("年龄" + this.age);
    }
}

使用this调用本类的构造器

• this可以作为一个类中 构造器相互调用的特殊格式

class Test { // 定义Person类
    private String name;
    private int age;
 
    public Test() { // 无参构造器
        System.out.println("新对象实例化");
    }
 
    public Test(String name) {
        this(); // 调用本类中的无参构造器
        this.name = name;
    }
 
    public Test(String name, int age) {
        this(name); // 调用有一个参数的构造器
        this.age = age;
    }
 
    public String getInfo() {
        return "姓名：" + name + "，年龄：" + age;
    }
}

注意：

• 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
• 明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
• 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 "this(形参列表)"
• "this(形参列表)"必须声明在类的构造器的首行！
• 在类的一个构造器中，最多只能声明一个"this(形参列表)"

关键字package 

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。

它的格式为：package 顶层包名.子包名 ;

package pack1.pack2; //指定类PackageTest属于包pack1.pack2
public class PackageTest{
    public void display(){
    System.out.println("in method display()");
    }
 
 }

• ​​​​​​包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
• 包通常用小写单词标识。通常使用所在公司域名的倒置：com.gu.xxx

​​​​​​包的作用：

• 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
• 包可以包含类和子包，划分项目层次，便于管理
• 解决类命名冲突的问题
• 控制访问权限

JDK中主要的包介绍

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

关键import

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

语法格式：

• import 包名. 类名;

应用举例：

import pack1.pack2.Test; //import pack1.pack2.*;表示引入pack1.pack2包中的所有结构
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组合的使用：调用指定类或接口下的静态的属性或方法