封装

基本介绍

• 该露的露，该藏的藏，我们的程序设计要追求“高内聚，低耦合”：
  • 高内聚：类的内部数据操作细节自己完成，不允许外部干涉
  • 低耦合：仅暴露少量的方法给外部使用
• 封装（数据的隐藏）：通常禁止直接访问一个对象中数据的实际表示，而因通过操作接口来访问，这称为信息隐藏
• 属性私有，get/set
• 为什么要使用封装：
  • 提高程序的安全性，保护数据
  • 隐藏代码的实现细节
  • 统一接口
  • 系统可维护增强
• 方法的重载：如println()方法，按住Ctrl，然后鼠标点击该方法则可以查看具体内容

运用实例

FengZhuang.java

public class FengZhuang {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("李同洲");
        System.out.println(stu1.getName());

        stu1.setAge(999);//岁数不合法，我们可以在Student类中的setAge()中对age进行约束
        System.out.println(stu1.getAge());
    }
}

Student.java

//Student类  private:私有
public class Student {
    //私有属性
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;

    //提供一些可以操作这些私有属性的方法
    //提供一些public的get和set方法

    //get 获得这个数据
    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }
    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

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

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

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

    public int getAge() {
        return age;
    }
    //学习（）

    //睡觉（）
}

继承

基本介绍

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
• extands的意思是“扩展”，子类是父类的扩展
• Java中类只有单继承，没有多继承
• 继承是类与类之间的一种关系。除此之外，类与类之间还存在依赖、组合、聚合等关系
• 继承关系的两个类，一个是子类(派生类)，一个是父类(基类)。子类继承父类，使用extands来表示
• 子类和父类之间，从意义上讲应该具有“is a”的关系
• super注意点：
  • super调用父类的构造方法，必须在构造方法的第一个
  • super只能出现在子类或者构造方法中
  • super和this不能同时调用构造方法
• this
  • 代表的对象不同：this本身调用着这个对象；super：代表父类对象的应用
  • 前提：this没有继承也可以使用；super只能在继承条件中使用
  • 构造方法：this本类的构造；super父类的构造
• 方法重写：需要有继承关系，子类重写父类方法
  • 方法名必须相同
  • 参数列表必须相同
  • 修饰符：范围可以扩大但是不可以缩小 （public>protected>default>private）
  • 抛出的异常：范围可以缩小但是不可以扩大 （ClassNotFindException<Exception）
• 重写子类的方法必须和父类的方法一致；方法体不同
• 为什么要重写？（父类的功能子类不一定需要，或者不一定满足！）

运用实例

Test：JiCheng.java

public class JiCheng {
    public static void main(String[] args) {
        WoMen nv1=new WoMen();
        System.out.println(nv1.money);
        nv1.say();
        System.out.println(nv1.getXing());
        nv1.setXing("洲");
        System.out.println(nv1.getXing());

        //super
        Man nan1=new Man();
        nan1.text("li");
        nan1.text2();
        
        
        //静态方法
        //方法的调用之和左边有关，定义的数据类型有关
        B b=new B();
        b.text();//B-->text()
        A a=new B();
        a.text();//A-->text()

        //方法的重写（Override重写）
        //非静态方法（非静态方法和静态方法是有很大的区别的）
        B c=new B();
        c.text();//B-->text()
        //父类的引用指向了子类
        A d=new B();//子类重写的父类的方法
        d.text();//B-->text()
    }
}

父类：Person.java

//在Java中，所有的类，都默认直接或者间接继承Object类
//父类
public class Person /*extends Object(可省略)*/ {
    //public
    //protected
    //default
    //private


    public Person() {
        System.out.println("Person无参");
    }

    /*public Person(String m) {
        System.out.println("Person有参");
    }*/

    public int money=10_0000_0000;//如果属性为private则不能直接继承给子类

    private String xing="李";//如果属性为private，需要通过get/set方法来获取数据，然后把get/set方法继承给子类

    public void say(){
        System.out.println("说话");
    }

    public String getXing() {
        return xing;
    }

    public void setXing(String xing) {
        this.xing = xing;
    }


    //super
    public String name="litongzhou";
    public void print(){
        System.out.println("Person");
    }
}

子类：WoMen.java

//女人 is 人：派生类 is 基类
//子类继承父类，就拥有父类的全部方法！
public class WoMen extends Person{
    //Ctrl+h
}

子类：Man.java

public class Man extends Person {

    //隐藏代码：调用了父类的无参构造
    public Man() {
        super();//调用父类的构造器，必须在子类构造器的的第一行
        System.out.println("Man无参");
    }

    /*public Man() {
        super("m");
        System.out.println("Man有参");
    }*/

    //super
    private String name="李同洲";
    public void text(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

    public void print(){
        System.out.println("Man");
    }

    public void text2(){
        print();
        this.print();
        super.print();
    }
}

父类：A.java

public class A {
    //重写都是方法的重写，和属性无关
    public  void text(){
        System.out.println("A-->text()");
    }
}

子类：B.java

public class B extends A{
    //Override重写
    @Override //注解：有概念的注解
    public void text() {
        System.out.println("B-->text()");
    }
}