java基础--面向对象（封装，继承，多态）

面向对象三大特性：封装，继承，多态。

封装：

将对象具有的一些属性和方法打包到一起，隐藏属性和方法的具体实现。即封装。隐藏类的实现细节，让使用者只能通过指定的方法访问数据，限制不合理操作。便于修改，增强代码的可维护性。

如何实现封装：

将成员变量声明为私有的，再提供一个或多个公有（public）set或get方法实现对该成员变量的访问和修改。

继承：

将一个已有类中的属性和方法保留，再加上自己特有的属性和方法形成一个新的类。即继承。通过extends实现。
要调用父类的构造方法，可用super关键字实现，若要调用父类特定的构造方法，则用super里面的参数确定，super()写在子类的构造函数中。，如super(name, age, sex, salary); 表示调用父类的public Person(String name, int age, String sex, Double salary)构造方法。特别注意，如果父类中有构造方法，则子类必须实现其构造方法，若父类没有构造方法，子类可以定义构造方法也可不定义。
代码演示：

//父类
public class Person {
     private  String name;
     private int age;
     private  String sex;
     private  Double salary;
     public Person(String name, int age, String sex,  Double salary) {
        super();
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.salary = salary;
    }
    public String getName(){
        return name;
    }
    public String setName(String name){
        return this.name=name;
    }
    public int getAge(){
        return age;
    }
    public int setAge(int age){
        return this.age=age;
    }
    public String getSex(){
        return sex;
    }
    public String setSex(String sex){
        return this.sex=sex;
    }
    public  Double getSalary(){
        return salary;
    }
    public Double setSalary(Double salary){
        return this.salary=salary;
    }
}

//子类
public class Student extends Person {
    private String school;
    public Student(String name, int age, String sex, Double salary) {
            super(name, age, sex, salary);          
        }
    public String getSchool(){
        return school;
    }
    public void setSchool(String school){
        this.school=school;
    }
    public static void main(String[] args) {
        Student p1=new Student("张三",20,"男",10000.98);
        Student p2=new Student("李四",18,"女",8001.98);
        System.out.println(p1.getName()+"的年龄是"+p1.getAge()+","+"性别是"+p1.getSex()+","+"工资是"+p1.getSalary());
        System.out.println();
        System.out.println(p2.getName()+"的年龄是"+p2.getAge()+","+"性别是"+p2.getSex()+","+"工资是"+p2.getSalary());
        p1.setName("王好");
        p1.setAge(90);
        p1.setSex("女");
        p1.setSalary(4025.90);
        System.out.println();
        System.out.println("姓名："+p1.getName()+"  年龄："+p1.getAge()+"  性别："+p1.getSex()+"  工资："+p1.getSalary());
    }
}

继承小结：

1. 如果一个类中没有显示extends任何类，则默认继承Object类。
2. Java只支持单继承，不支持多继承。若要实现多继承，可以由类B继承类A，类C继承类B。
3. 子类只继承父类的成员变量和成员方法，不继承父类的构造方法，若要继承父类的构造方法，可在子类的构造方法中使用super构造方法。
4. 继承的成员只能为非private的变量和方法，如果父类的方法为private，子类中同名，同参，同返回值类型方法相当于定义了一个新方法，与父类没有任何关系。

多态：

同名但有不同的具体实现的多个方法同时存在于一个类中。多态的体现方式：方法重载和方法重写。

方法重写：发生在父类与子类中。子类与父类中方法名，参数类型及个数，返回值都相同，只有方法体不同，叫做方法重写。方法重写需注意一下几点：

1. 如果在子类中想调用父类中那个被重写的方法，可以使用super.方法名（参数列表）。
2. 重写方法时，被重写的方法访问权限不能比父类低，访问权限由高到低一次为：public,protected,default,private。
   例如：

//父类
 public void Run(){
        System.out.println("欢迎来到！");
    }

//子类
 public void Run(){
        System.out.println("你好，晚安");
    }

方法重载：发生在同一个类中，同一个类中有多个方法名相同，返回值类型相同，但是参数类型和个数不同的方法就是方法重载。

例如：

//方法重载发生在同一个类中
public void Run( String n){
        System.out.println("欢迎来到！"+n);
    }
public void Run( int m){
        System.out.println("你好，晚安"+m);
    }