封装-继承

知识点

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 修饰的属性赋值。

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类的访问修饰符

6.4类 成员访问修饰符

  • 访问权限从大到小 public --> protected --> 缺省 --> private
  • 访问修饰符 不能修饰局部变量

总结

今天学习了面向对象三大特征中的封装和继承,还是相当有难度的,然后今天晚上还复习了一下之前的知识,明天就是Java开课以来第一次的周考了,还要多看一下二分法查找,冒泡,arraycopy的代码。

标签

评论

© 2021 成都云创动力科技有限公司 蜀ICP备20006351号-1