知识点

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的代码。