Java学习之旅（day.09）

封装

把数据包装起来，给你能看的，不能看的包装起来不让你看

该露的露，该藏的藏

程序设计要求“高内聚，低耦合”。

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

低耦合指仅暴露少的方法给外部使用

属性私有，get/set

有时set中会做一些安全性的验证或判断

封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

package com.zhang.oop.demo04;
//private 私有
public class Student {
//属性私有
    private  String name;
    private int id;
    private char sex;
    private int age;

    //此时new了对象，属性也无法直接操作，要用get/set提供一些可以操作这个属性的方法
    //要用一些public的get、set方法
    //get 获得这个数据
    public String getName(){//这样就可以把name获取到了
     return this.name;
    }
    //set 给这个数据设置值
    public  void setName(String name){//形式参数
    this.name=name;
    }
    //alt+insert 可以自动生成get set方法

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0){
            this.age = 3;
        }else {
            this.age = age;
        }
    }
}

/*
package com.zhang.oop.demo04;
import com.zhang.oop.demo04.Student;

//一个项目应该只存在一个main方法

封装的意义：
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.提高系统的可维护性
 
public class Application {//总的测试类

    public static void main(String[] args) {
        //new实例化了一个对象
        Student s1=new Student();
//此处此时若用s1.name="旺财";会报错，但用public不会报错,但是可以通过getName的方式获取name
//String name =s1.getName();
        s1.setName("zhang");
        System.out.println(s1.getName());

        s1.setAge(999);//这样的年龄不合法，可以在get set方法中规避掉
        System.out.println(s1.getAge());
    }
}
//以对象的形式封装数据           //实例
 */

继承

继承的本质是对类的抽象，从而实现对现实世界更好的建模

extends：扩展。子类是父类的扩展。

子类继承父类，使用关键字extends来表达

子类和父类之间，从意义上讲应该具有“is a ”的关系

java中类只有单继承，无多继承（子类只有一个父类，但父类可以有多个子类）

继承是类更类间的关系，除此之外，类与类间的关系还有依赖、组合、聚合等

package com.zhang.oop.demo05;
//person 父类
//java中，所以的类都直接或间接的继承object类
public class Person {
     //public
     //protected
     //default ：若不写任何修饰符，默认为这个                几个修饰符
     //private
    //public int money=10_0000_0000;若此处用publi可直接操作
    private int money=10_0000_0000;//但当用成public，不可直接操作，需按方法操作get、set
    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

/*
package com.zhang.oop.demo05;
//学生是人,父类：人；子类（也叫派生类）：学生、老师。
public class Student extends Person {
    //子类可以继承父类的所有方法
    //子类继承父类就会拥有父类的全部方法,前提是父类person中的修饰符为public，若改为private就不行了
    //ctrl+h 可以在右侧显示出所写的继承关系
}


package com.zhang.oop;

import com.zhang.oop.demo05.Student;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.say();
        //System.out.println(student.money);
        System.out.println(student.getMoney());
    }
}

 */

super

super和this

super的注意点：

1. super可以用来调用父类的构造方法，且位置必须处在子类代码构造器的第一个
2. super必须且只能出现在子类的方法或构造方法中
3. super和this不能同时调用构造方法

super和this的区别

1. 代表的对象不同

this代表本身调用者这个对象（谁调用了他就是谁）

super代表父类对象的引用

2. 使用前提不一样

this：this这个关键字可以直接使用，在没有继承的情况下也可以使用

super：只能在继承条件下才可以使用

3. 调用构造方法不一样

this（）；调用的是本类的构造方法

super（）；调用的是父类的构造方法

package com.zhang.oop;


import com.zhang.oop.demo06.Person;
import com.zhang.oop.demo06.Student;


public class Application {
    public static void main(String[] args) {

        Student student=new Student();
        //student.test("张三");
       // student.test1();

    }

}
/*
package com.zhang.oop.demo06;

public class Person {
    //无参构造器

     public Person(String name){
        System.out.println("Person无参构造执行了");
       //若把此处改为有参构造，即：public Person(String name){},因为只要你写了有参构造，无参构造就没了，此时在子类Student中隐藏的代码会报错：'Person(java.lang.String)' in 'com.zhang.oop.demo06.Person' cannot be applied to '()'，此时调用父类的无参出错，但你调用父类的有参是可以的，即给super加上参数：super（”name“）
         // 所以，只要重写了有参，就先把无参构造加上
    }

    protected  String name="zhang";
    public void print(){//如此处public改为private，会出错：私有的属性无法继承

        System.out.println("person");

    }
}


package com.zhang.oop.demo06;

public class Student extends Person  {
    //子类也来一个构造器

    public Student() {
        //new Student最后输出的结果是：Person无参构造执行了
        //                          Student无参构造执行了
        //new 的是Student，本不应该有Person这句话，有说明这里有隐藏代码，默认的调用了父类Person的无参构造器
        super("name");//这行就是隐藏的代码
        System.out.println("Student无参构造执行了");
        //super(); 若将此代码放在此处（子类的下方），会报错。即调用父类的构造器，super必须要在子类构造器的第一行

    }

    private String name = "xian";
    public void print(){
        System.out.println("Student");
    }
public void test1(){
        print();
        this.print();
        super.print();
}
    public void test(String name) {
        System.out.println(name);//张三 传递过来的参数，此处的name是当前的String name，即传递的参数
        System.out.println(this.name);//xian 当前类里面的东西 此处的name指代的是上面private的name
        //在子类Student中如何访问父类Person中的属性
        System.out.println(super.name);//zhang 父类中的，
        // 此处的name指代的是父类Person中的name

    }
}
 */