Java学习第19天

封装和隐蔽：

高内聚，低耦合：

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅对外暴露少量的方法用于使用

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界的调用。从而提高系统的可扩展性        、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想

/*
 * 面向对象的特征一：封装与隐藏
 * 一、问题的引入：
 *     当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的
 *     属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。
 *     除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值
 *     加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行
 *     限制条件的添加。（比如：setLegs()）
 *     同时我们需要避免用户再使用"对象.属性"的方式进行赋值。则需要将属性声明为
 *     私有的(private)。
 * -->此时，针对于属性就体现了封装性。
 * 
 * 二、封装的体现：
 * 我们将类的属性私有化(private)，同时，提供公共的(public)方法来获取(getXxx)
 * 和设置(setXxx)此属性
 * 
 *     拓展：封装性的体现：①如上 ② 不对外暴露的私有的方法 ③单例模式 ...
 * 
 * 三、封装性的体现、需要权限修饰符来配合。
 * 1.Java规定的4种权限（从小到大排列）：private、缺省、protected、public
 */
public class AnimalTest {
    public static void main(String[] args) {
        
        Animal a = new Animal();
        a.name = "大黄";
//        a.age = 1;
//        a.legs = 4;The field Animal.legs is not visible
        a.show();
        
        a.setLegs(-6);//0
        a.show(); 
    }
}
class Animal{
    String name;
    private int age;
    private int legs;//腿的个数
    
    //对属性的设置
    public void setLegs(int l) {
        if(l >= 0 && l % 2 == 0) {
            legs = l;
        }else {
            legs = 0;
        //抛出一个异常    
        }
    }
    //对属性的获取
    public int getLegs() {
        return legs;
    }
    
    public void eat() {
        System.out.println("动物进食");
    }
    public void show() {
        System.out.println("name = " + name + "，age = " + age +"，legs = " + legs);
    }
    
    //提供关于属性age的get和set方法
    public int getAge() {
        return age;
    }
    public void setAge(int a) {
        age = a;
    }
    
}

public class OrderTest {
    public static void main(String[] args) {
        
        Order order = new Order();
        
        order.orderDefault = 1;
        order.orderPublic = 2;
        //出了Order类之后，私有的结构就不可以调用了
//        order.orderPrivate = 3;//The field Order.orderPrivate is not visible
        
        order.methodDefault();
        order.methodPublic();
        //出了Order类之后，私有的结构就不可以调用了
//        order.methodPrivate();
        
        
        
    }
    
}

import com.nhy.java.Order;

public class OrderTest {
    public static void main(String[] args) {
Order order = new Order();
        
        order.orderPublic = 2;
        
        //order.orderDefault = 1;
        //出了Order类所属的包之后，缺省声明的结构就不可以调用了
        //出了Order类之后，私有的结构就不可以调用了
//        order.orderPrivate = 3;//The field Order.orderPrivate is not visible
        
        order.methodPublic();
        
        //order.methodDefault();
        //出了Order类所属的包之后，缺省声明的结构就不可以调用了
        //出了Order类之后，私有的结构就不可以调用了
//        order.methodPrivate();
        
         
        
    }
}

 构造器：

/*
 * 类的结构之三：构造器（构造方法、constructor）的使用
 * construct:建设、建造。construction：CCB（中国建设银行）
 *                         constructor：建设者
 * 一、构造器的作用：
 * 创建对象
 * 
 * 二、说明：
 * 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
 * 2.定义构造器的格式：权限修饰符 类名（形参列表）{}
 * 
 */
public class PersonTest {
    public static void main(String[] args) {
        //创建类的对象
        Person p = new Person();
        
        p.eat();
        
    }
}
class Person{
    //属性
    String name;
    int age;
    
    //构造器
    public Person(){
        System.out.println("Person().....");
    }
        
    //方法
    public void eat() {
        System.out.println("人吃饭");
    }
    public void study() {
        System.out.println("人可以学习");
    }
}