Java基础速通(有C基础)-封装、继承、方法的重写

Ps：public 不仅在本类里面可以调用，同一个包下的其他类也可以调用。

一.封装

        1.封装的思想

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

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

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

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

        2.代码实现

        在test04包下创建Girl类和Test类：

        

        Girl.java中的代码：

    

package com.test04;

public class Girl {
    private int age;
    //给age提供一个赋值方法：
    public void Setage(int age){
        if(age>30){
            this.age = 18;
        }else{
            this.age = age;
        }
    }
    //给age提供一个读取值的方法：
    public int Getage(){
        return age;
    }
}

Test.java中的代码：

        

package com.test04;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Girl g = new Girl();
        g.Setage(33);
        System.out.println(g.Getage());
    }
}

运行Test.java中的代码：

        

若g.Setage(33);改为g.Setage(26);  则运行结果为:

        

二.继承

Ps：类是对对象的抽象。继承是对类的抽象

        1.继承的格式：

        子类 extends 父类

        2.代码实现：

        在test05这个包下分别创建父类-Person，子类-Student，测试类-Test。

        

Ps:当用private修饰词定义变量时，可以用快捷键Alt+insert来快速创建get,set方法。

Person.java中的代码：

        

package com.test05;

public class Person {
    //父类公共的属性：
    private String name;
    private int age;
    private double height;

    //父类公共的方法：
    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 double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    //吃饭
    public void eat(){
        System.out.println("人类可以吃饭");
    }
    //睡觉
    public void sleep(){
        System.out.println("人类可以睡觉");
    }
    //喊叫
    public void shout(){
        System.out.println("人类可以喊叫");
    }

}

Student.java中的代码：

package com.test05;

public class Student extends Person{//子类Student继承父Person
    //定义子类额外的、扩展的属性
    private int Num;

    //定义子类额外的、扩展的方法
    public int getNum() {
        return Num;
    }

    public void setNum(int num) {
        Num = num;
    }
    //学习
    public void study(){
        System.out.println("学生可以学习");
    }
}

Test.java中的代码：

package com.test05;

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        //属性
        s.setNum(00000001);
        //可以直接调用父类中的:(因为Student已经继承父类Person)
        s.setAge(23);
        s.setName("周风");
        s.setHeight(177.23);

        //方法
        s.study();
        //可以直接调用父类中的:
        s.eat();
        s.sleep();
        s.shout();
    }

}

运行Test.java得到的结果：

        

        3.继承的好处：

                （1）提高了代码的复用性。

                （2）便于代码的扩展。

                （3）为了多态的使用，是多态使用的前提。

三、方法的重写

        1.什么是重写

        重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。

        重写的好处在于子类可以根据需要，定义特定属于自己的行为。也就是说子类能够，根据需要实现父类的方法。

        2.代码实现：

        在test06这个包下分别创建父类-Person，子类-Student，测试类-Test。

        

        Person.java中的代码：        

        

package com.test06;

public class Person {
    public void eat(){
        System.out.println("人类可以吃饭");
    }
}

  Student.java中的代码:

package com.test06;

public class Student extends Person{
    public void eat(){
        System.out.println("我喜欢吃烤鸭");
    }
}

        Test.java中的代码:

        

package com.test06;

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.eat();
    }
}

         Test.java中的代码运行结果：

        

Ps: