Java学习（Day9）第四章：封装，隐藏，关键字，构造器

4.7 面向对象特征之一：封装和隐藏

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

        Animal a = new Animal();
        a.name = "大象";
        //a.age = 1;
        a.setLegs(6);
        a.eat();
        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;
    }


    //提供关于属性age的get和set方法

    public int getAge(){
        return age;
    }
    public void setAge(int a){
        age = a;
    }
    public void eat(){
        System.out.println("动物进食");
    }
    public void show(){
        System.out.println("名字为" + name + "年龄为" + age + "腿数为" + legs);


    }

}

4.8 类的成员之三：构造器

package atguigu.com;

/*
 * 类的结构之三：构造器（或构造方法、constructor）的使用
 * construct:建设，建造 construction:CCB  constructor:建设者
 * 
 * 一、构造器的作用：
 * 1.创建对象
 * 2.初始化对象的信息
 * 3.一个类中定义的多个构造器，彼此构成重载。
 * 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器。
 * 5.一个类中，至少会有一个构造器。
 * 二、说明：
 * 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
 * 2.定义构造器的格式，权限修饰符 类名（形参列表）{}
 * 
 */
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("人在学习");
    }

}

属性赋值的先后顺序

package atguigu.com;
/*
 * 总结：属性赋值的先后顺序
 * 
 * 
 * 1.默认初始化
 * 2.显式初始化
 * 3.构造器中赋值
 * 4.通过"对象.方法"或"对象.属性"的方式，赋值
 * 
 * 
 * 以上操作的先后顺序1-2-3-4
 */
public class UserTest {
        public static void main(String[] args) {
            User u = new User();

            System.out.println(u.age);

            User u1 = new User(2);
            u1.setAge(3);
            System.out.println(u1.age);
        }
}

class User{
    String name;
    int age = 1;

    public void setAge(int a){
        age = a;
    }

    public User(){

    }
    public User(int a){
        age = a;
    }

}

拓展知识javabean

package atguigu.com;
/*
 * JavaBean是一种Java语言写成的可重用组件
 * 
 * 所谓javaBean,是指符合如下标准的Java类
 *   >类是公共的
 *   >有一个无参的公共的构造器
 *   >有属性，且有对应的get,set方法。
 */
public class Customer {

    private int id;
    private String name;

    public Customer(){

    }
    public int getId(){
        return id;
    }
    public void setId(int i){
        id = i;
    }
    public String getname(){
        return name;
    }
    public void setname(String j){
        name = j;
    }
}

4.9关键字this的使用

package atguigu2.com;
/*
 * this关键字的使用：
 * 1.this可以用来修饰属性、方法、构造器
 * 
 * 2.this修饰属性和方法：
 *         this理解为：当前对象
 *        
 *    2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。
 *        但是，通常情况下，我们都选择省略"this."特殊情况下如果方法的形参和类的属性重名时，
 *        我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
 *    2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。
 *        但是，通常情况下，我们都选择省略"this."特殊情况下如果方法的形参和类的属性重名时，
 *        我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
 * 3.this修饰构造器
 *        1.我们在类的构造器种，可以显式的使用"this(形参列表)"方式，调用本类的其他构造器
 *        2.构造器种不能通过"this(形参列表)"方式调用自己
 *        3.如果一个类中有n个构造器，则最多有n-1个构造器种使用"this(形参列表)"方式。
 *        4.规定："this(形参列表)"方式必须声明在当前构造器的首行
 *        5.构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器。
 */
public class PersonTest {
    public static void main(String[] args){
        Person p1 = new Person();

        p1.setage(1);
        System.out.println(p1.getAge());
        Person p2 = new Person("Jerry",20);
        System.out.println(p2.getAge());
    }
}

class Person{
    private String name;
    private int age;

    public Person(){

    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }



    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setage(int age){
        this.age = age;
    }    
    public int getAge(){
        return age;
    }
}