封装与继承

1.继承

1.1继承的作用

• 代码重用，增加软件的可扩展性。

1.2继承的特点

• 可以继承父类中用 public 和 protected 和 Package-Access 修饰的属性和方法， Package- Access 修饰的属性和方法只能在同包中继承。 private 修饰属性和方法不能被继承。

• 父类的构造方法不能被继承

• 子类可以扩展

• 子类可以重写 Override 父类的方法,不能重写构造方法

• 提高类之间的耦合性

2.重写

2.1重写的定义

• 重写(Override) 一般发生在继承中，描述子类重写父类的方法。当父类的方法不能满足子类的需求时，子类可以重写此方法，也叫覆盖。

• 子类中有和父类中同名且同参（相同）注意返回值的类型也要相同，不然编译时候会报错的方法，成为方法的重写（覆盖）

  public class Student extends Person{ 
      //扩展 
      public void study() { 
          System.out.println("study"); }
      //重写父类eat()
      @Override //重写的意思
      public void eat() { 
          System.out.println("eat everything what i want"); 
      } 
  }
  

2.2方法的重写时需要满足的条件

• 重写一定发生 在继承关系中

• 重写方法与被重写的方法要相同（方法名称，返回值，参数）

• 重写的访问权限不能变小

2.3注意

• 注意: 不能重写父类中 final 修饰的方法，不能重新给 final 修饰的属性赋值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lJDWp8MO-1601101277151)(C:\Users\admin\Desktop\重载与重写的区别.png)]

3.final

3.1final的概念

• final 修饰的类不能被继承， final 修饰的属性（字段）不可修改， final 修饰的方法不能被重写。

3.2fanal的使用

• final 修饰变量称为常量，常量必须在赋初始值后才能使用，且不能更改

  public static void main(String[] args) { 
      final int num ;
      num = 10; 
      // num ++ ; //错误的，不能改变num的值 
      System.out.println(num); 
  }
  

• final 修饰对象，因为对象本身是可变的，不可变的是变量对于对象的引用

  final Dog dog = new Dog(); 
  dog.setName("二哈"); //修改name 
  dog.setColor("gray"); //修改color 
  //dog = new Dog(); //错误的写法，不能改变dog的引用
  

• final 自变量，将方法的参数设置为 final 类型,表示在方法中，此参数不能改变

  public void add(final int num) { 
  }
  

4.子类和父类的关系

• 在子类进行实例化时，调用父类的构造方法。在子类的构造方法中要调用父类的构造方法，而且是先调用父类构造在执行子类构造方法中的其他语句。

• 当父类中有无参构造时，子类的构造方法可以不写调用父类构造( super() ), java 会自动在子类构造方法的第一行加上 super() ;但是，如果父类中没有无参构造，就需要我们手动在子类构造中调用父类的构造方法。

• 注意：要实例化子类就得先实例化父类

5.概念

5.1遮蔽（ shadowing）

• 有些声明可能在其作用域的一部分被相同名称的另一个声明遮蔽。

  class Test { 
      static int x = 1; 
      public static void main(String[] args) { 
          int x = 0; 
          System.out.print("x=" + x); 
          System.out.println(", Test.x=" + Test.x); 
      } 
  }
  

5.2隐藏(hiding)

• 用于将被继承但由于子类中的声明而不被继承的成员

  class Super{ 
      int x = 10; 
      static int y = 20; 
  }
  class Sub extends Super{ 
      int x = 11; 
      static int y = 21; 
      public void test(){ 
          System.out.println("this.x = " + this.x); // x in class Sub 
          System.out.println("super.x = " + super.x);// x in class Super 
          System.out.println("this.y = " + this.y); // y in class Sub 
          System.out.println("Sub.y = " + Sub.y); // y in class Sub 
          System.out.println("super.y = " + super.y); // y in class Super 
          System.out.println("Super.y =" + Super.y); // y in class Super 
      }
      public static void main(String[] args) { 
          Sub sub = new Sub(); 
          ub.test(); 
      } 
  }
  

  this.x = 11 
  super.x = 10 
  this.y = 21 
  Sub.y = 21 
  super.y = 20 
  Super.y =20
  

6.封装

6.1封装的概念

• 封装就是对类内部细节进行隐藏，对外不可见。外部程序不能直接访问。

• 有效避免外部错误对对象的影响。让使用者只能通过规定的方式来访问数据。是通过访问修饰符来限制不合理的操作。

6.2访问 修饰符

• 访问修饰符可以限制和制约类之间的访问。访问修饰符有四种(三个关键字)：

  • public ： 公开的/公共的
  • protected ： 受保护的
  • 什么都不写(Package-Access) ： 包访问修饰符
  • private ： 私有的

6.3类的访问修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nLA6Q6jD-1601101277153)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20200925203252411.png)]

6.4类 成员访问修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Trz751wD-1601101277155)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20200925203336530.png)]

• 访问权限从大到小 public --> protected --> 缺省 --> private

• 访问修饰符 不能修饰局部变量

277153)]

6.4类 成员访问修饰符

[外链图片转存中…(img-Trz751wD-1601101277155)]

• 访问权限从大到小 public --> protected --> 缺省 --> private

• 访问修饰符 不能修饰局部变量