java学习——封装继承

java封装继承
封装
1、封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。
通过该类提供的方法来实现对隐藏信息的操作和访问。
隐藏对象的信息。
留出访问的对外接口。

2、封装的特点：
对成员变量实行更准确的控制。
封装可以隐藏内部程序实现的细节。
良好的封装能够减少代码之间的耦合度。
外部成员无法修改已封装好的程序代码。
方便数据检查，有利于保护对象信息的完整性，同时也提高程序的安全性。
便于修改，体高代码的可维护性。
1.2，封装的使用：
使用private修饰符，表示最小的访问权限。
对成员变量的访问，统一提供setXXX，getXXX方法。
下面请看一个Student实体对象类：

public class Student implements Serializable {
    
    private Long id;
    private String name;
    private Integer sex;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getSex() {
        return sex;
    }

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

将对象中的成员变量进行私有化，外部程序是无法访问的。但是我们对外提供了访问的方式，就是set和get方法。

3、继承
​ 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。

4、继承的特点：
（1）关于继承的注意事项：
​ 只支持单继承，即一个子类只允许有一个父类，但是可以实现多级继承，及子类拥有唯一的父类，而父类还可以再继承。

​ 子类可以拥有父类的属性和方法。

​ 子类可以拥有自己的属性和方法。

​ 子类可以重写覆盖父类的方法。

（2）继承的特点：

提高代码复用性。

父类的属性方法可以用于子类。

可以轻松的定义子类。

使设计应用程序变得简单。
5、继承的使用
（1）在父子类关系继承中，如果成员变量重名，则创建子类对象时，访问有两种方式。

a，直接通过子类对象访问成员变量

​ 等号左边是谁，就优先使用谁，如果没有就向上找。

b，间接通过成员方法访问成员变量

该方法属于谁，谁就优先使用，如果没有就向上找。

public class FU {
    int numFU = 10;
    int num = 100;
    public void method(){
        System.out.println("父类成员变量："+numFU);
    }
    public void methodFU(){
        System.out.println("父类成员方法!");
    }
}
public class Zi extends FU{
    int numZi = 20;
    int num = 200;
    public void method(){
        System.out.println("子类成员变量："+numFU);
    }
    public void methodZi(){
        System.out.println("子类方法！");
    }
}
public class ExtendDemo {
    public static void main(String[] args) {
        FU fu = new FU();
        // 父类的实体对象只能调用父类的成员变量
        System.out.println("父类：" + fu.numFU);   // 结果：10
        
        Zi zi = new Zi();
        System.out.println("调用父类：" + zi.numFU); // 结果：10
        System.out.println("子类：" + zi.numZi);   // 结果：20

        /** 输出结果为200，证明在重名情况下，如果子类中存在则优先使用，
         *  如果不存在则去父类查找，但如果父类也没有那么编译期就会报错。
         */
        System.out.println(zi.num); // 结果：200
        /**
         * 通过成员方法调用成员变量
         */
        zi.method();    // 结果：10
    }
}

（2）同理：

​ 成员方法也是一样的，创建的对象是谁，就优先使用谁，如果没有则直接向上找。
​ 注意事项：

​ 无论是成员变量还是成员方法，如果没有都是向上父类中查找，绝对不会向下查找子类的。

（3）在继承关系中，关于成员变量的使用：

​ 局部成员变量：直接使用
​ 本类成员变量：this.成员变量
​ 父类成员变量：super.父类成员变量

int numZi = 10;
 public void method() {
   int numMethod = 20;
   System.out.println(numMethod);  // 访问局部变量
   System.out.println(this.numZi); // 访问本类成员变量
   System.out.println(super.numFu); // 访问本类成员变量
}

（3）重写，重载
​ 重写(override)
​ 是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

class Animal{
   public void move(){
      System.out.println("动物行走！");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
   }
}

​ 重写的规则：

​ 1，参数列表必须与被重写方法相同。

​ 2，访问权限不能比父类中被重写的方法的访问权限更低（public>protected>(default)>private）。

​ 3，父类成员的方法只能被它的子类重写。

​ 4，被final修饰的方法不能被重写。

​ 5，构造方法不能

重载(overload)

​ 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

​ 最常用的地方就是构造器的重载。

  public class Overloading {
       public int test(){
           System.out.println("test1");
           return 1;
       }
       public void test(int a){
           System.out.println("test2");
       }   
       //以下两个参数类型顺序不同
       public String test(int a,String s){
           System.out.println("test3");
           return "returntest3";
       }   
       public String test(String s,int a){
           System.out.println("test4");
           return "returntest4";
       }    
       public static void main(String[] args){
           Overloading o = new Overloading();
           System.out.println(o.test());
           o.test(1);
           System.out.println(o.test(1,"test3"));
           System.out.println(o.test("test4",1));
       }
   }

​ 重载规则：

​ 1，被重载的方法必须改变参数列表（参数个数或者类型不一样）。

​ 2，被重载的方法可以改变返回类型。

​ 3，被重载的方法可以改变访问修饰符。

3.5，this，super关键字
super()关键字的用法
​ 1，子类的成员方法中，访问父类的成员变量。

​ 2，子类的成员方法中，访问父类的成员方法。
3，子类的构造方法中，访问父类的构造方法。

this关键字用法：
​ 1，本类成员方法中，访问本类的成员变量。
​ 2，本类成员方法中，访问本类的另一个成员方法。
3，本类的构造方法中，访问本类的另一个构造方法。
​ 注意：

this关键字同super一样，必须在构造方法的第一个语句，且是唯一的。
this与super不能同时存在。