Java入门教程九(封装继承多态)

封装

封装就是将对象的属性和方法相结合，经过方法将对象的属性和实现细节保护起来，实现对象的属性隐藏。作法就是：修改属性的可见性来限制对属性的访问，并为每一个属性建立一对取值（getter）方法和赋值（setter）方法，用于对这些属性的访问。

public class Person
{
    private String name;     //姓名
    private int age;         //年龄
    private String phone;    //联系电话
    private String address;  //家庭住址
    
    public String getName()
    {
        return name;
    }
    
    public void setName(String name)
    {
        this.name=name;
    }
    
    public int getAge()
    {
        return age;
    }
    
    public void setAge(int age)//封装的经常使用表现，在内部进行业务逻辑的控制，外部只调用便可
    {
        if(age<18||age>40)//对年龄进行限制
        {
            System.out.println("年龄必须在18到40之间！");
            this.age=20;    //默认年龄
        }
        else
        {
            this.age=age;
        }
    }
    
    public String getPhone()
    {
        return phone;
    }
    
    public void setPhone(String phone)
    {
        this.phone=phone;
    }
    
    public String getAddress()
    {
        return address;
    }
    
    public void setAddress(String address)
    {
        this.address=address;
    }
}

继承

继承是代码复用的一种形式，即在具备包含关系的类中，从属类继承主类的所有属性和方法，从而减小了代码冗余，提升了程序运行效率。例如，一个矩形（Rectangle类）属于四边形（Quadrilateral），正方形、平行四边形和梯形一样都属于四边形。从类的角度来解释，能够说成 Rectangle 类是从 Quadrilateral 类继承而来的，其中 Quadrilateral 类是基类，Rectangle 类是派生类。

继承是经过扩展其余类而造成新类来实现的，原来的类称为父类（super class）或基类，新类称为原来类的子类或派生类。在子类中，不只包含父类的属性和方法，还能够增长新的属性和方法，使得父类的基本特征可被全部子类的对象共享。类的继承并不改变类成员的访问权限。也就是说，若是父类的成员是公有的、被保护的或默认的，它的子类仍具备相应的这些特性。

class class_name extends extend_class
{
    //类的主体
}
public class Person
{
    public String name;   //姓名
    public int age;       //年龄
    public String sex;    //性别
}
public class Student extends Person
{
    private String stuNo;         //学号
    private String department;    //所学专业
}
//学生继承了人类，同时具备了，姓名、年龄、性别属性

多态

多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承以后，能够具备不一样的数据类型或表现出不一样的行为，这使得同一个属性或方法在父类及其各个子类中具备不一样的含义。

对面向对象来讲，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不一样来区分不一样的方法。经过编译以后会变成两个不一样的方法，在运行时谈不上多态。而运行时多态是动态的，它是经过动态绑定来实现的，也就是你们一般所说的多态性。

public class Figure
{
    double dim1;
    double dim2;
    Figure(double d1,double d2)//有参的构造方法
    {
        this.dim1=d1;
        this.dim2=d2;
    }
    double area()//用于计算对象的面积
    {
        System.out.println("经过多态，在子类中重写。");
        return 0;
    }
}
public class Rectangle extends Figure
{
    Rectangle(double d1,double d2)
    {
        super(d1,d2);
    }
    double area()
    {
        System.out.println("长方形的面积：");
        return super.dim1*super.dim2;
    }
}
public class Triangle extends Figure
{
    Triangle(double d1,double d2)
    {
        super(d1,d2);
    }
    double area()
    {
        System.out.println("三角形的面积：");
        return super.dim1*super.dim2/2;
    }
}
public static void main(String[] args)
{
    Figure figure;                     //声明Figure类的变量
    figure=new Rectangle(9,9);
    System.out.println(figure.area()); //输出：长方形的面积：81。
    figure=new Triangle(6,8);
    System.out.println(figure.area()); //输出：三角形的面积：24。
}

重载

重载是 Java 多态性的表现。在 Java 语言中，同一个类中的两个或多个方法能够共享同一个名称，只要它们的参数声明不一样便可，这种状况被称为方法重载

在 JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法

public void printin(int i){…}
public void println(double d){…}
public void println(String s){…}
System.out.println(102);       //调用println(int i)方法
System.out.println(102.25);    //调用println(double d)方法
System.out.println("价格为 102.25");    //调用println(String s)方法

方法重载时必需要注意如下两点：

重载方法的参数列表必须和被重载的方法不一样，而且这种不一样必须足以清楚地肯定要调用哪个方法。

重载方法的返回值类型能够和被重载的方法相同，也能够不一样，可是只有返回值类型不一样不能表示为重载。

pubic class Person{
    private String name;
    //方法一
    public Person(){
    }
    //重载方法，可直接设置姓名
    public Person(String _name){
        this.name = _name;
    }
}

重写

子类中若是建立了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不一样，以实现不一样于父类的功能，这种方式被称为方法重写，又称为方法覆盖。
在重写方法时，须要遵循下面的规则：
参数列表必须彻底与被重写的方法参数列表相同，不然不能称其为重写。
返回的类型必须与被重写的方法的返回类型相同，不然不能称其为重写。
访问修饰符的限制必定要大于被重写方法的访问修饰符（public>protected>default>private）。
重写方法必定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例女口，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，能够抛出非检査异常。

public class Person
{
    public String name;    //名字
    public int age;        //年龄
    public Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String getInfo()
    {
        return "我叫"+name+"，今年"+age+"岁";
    }
}
public class Student extends Person
{
    private String hobby;
    public Student(String name,int age,String hobby)
    {
        super(name,age);
        this.hobby=hobby;
    }
    public String getInfo()
    {
        return"我叫"+this.name+"，我今年"+this.age+"岁，我爱吃"+hobby+"。";
    }
}
public static void main(String[] args)
{
    Person person=new Student("小明",20,"鸡");
    System.out.println(animal.getInfo());  //输出：我叫小明，我今年20岁，我爱吃鸡。
}