面向对象（二）

一、封装

封装使得对代码的修改更加安全和容易。将代码分成了一个个相对独立的单元。

封装所带来的好处是：明确的指出了那些属性和方法是外部可以访问的。这样当你需要调整这个类的代码时，只要

保证公有(Public:)属性不变，公有方法的参数和返回值类型不变，那么你就可以尽情的修改这个类，而不会影响到

程序的其他部分，或者是使用到这个类 的其他程序。这就是为什么说的“在 OOP 中，对代码访问控制得越严格，

日后你对代码修改的自由就越大”。

封装使整个软件开发复杂度大大降低，能很好的使用别人的类（class），而不必关心其内部逻辑是如何实现的。

你能很容易学会使用别人写好的代码，这就让软件协同开发的难度大大降低。

封装还避免了命名冲突的问题。封装有隔离作用。电话上的按键和电视遥控器上的按键肯定用处不同。但它们都可

以叫做按键，为什么你没有弄混呢？很显然一个属于电话类一个属于遥控器类。不同的类中可以有相同名称的方法

和属性，但不会混淆。

1、访问权限

通过访问权限 public protected default private 来封装类、方法及属性，达到隐藏细节的目的，最终达到“该露的

露，不该露的别瞎露”目的。

2、PO：Javabean

在编写 javabean 中的有一些常用的规则如: 1)、属性尽可能私有化 private 2)、访问器: setter 与 getter 访问器

>private ，一般 public 居多

setterXxx: 存储 与 getterXxx: 查看

public class Person { //姓名 private String name; //年龄 private int age; //性别 private boolean sex; public Person() { } //setter与getter public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public boolean isSex() { return sex; } public void setSex(boolean sex) { this.sex = sex; }

二、类的继承

1、继承

继承：子承父业

继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。同时使用

继承可以提高代码的复用性。（事实上，利用组合可以更好的实现代码复用！）extends的意思是“扩展”。子类是

父类的扩展。

语法规则： java中使用extends关键字实现类的继承机制

<modifier> class <name> [extends <superclass>]{}

作用：

实现代码的复用，延续+扩展父类信息。

通过继承，子类自动拥有了基类的所有成员（成员变量和成员方法）。

注意：

java 中只有单继承，没有像 c++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。 “一个

孩子只有一个亲爸爸” 。

即 Java只支持单继承，不允许多继承：一个子类只能拥有一个直接基类，但是一个基类可以派生出多个子类

2、重写

父类不满足子类的要求，按需改写。注意 方法签名必须相同

“==”：方法名、形参列表相同。

“≤≤”：返回值类型(基本类型必须相同)和异常类型，子类小于等于父类。

“≥”：访问权限，子类大于等于父类

class F{ int test(int a){ return a*100; } } class C{ //重写 public int test(int a){ return a*100*100; } }

注意属性不会重写 注意以下方法不会重写

1、静态方法不会重写 ，父类为静态，子类只能为静态，否则编译错误

2、fifinal 修饰方法 否则编译错误

3、私有方法不会重写

3、Object继承链

Object 类是所有 Java 类的根基类

如果在类的声明中未使用 extends 关键字指明其基类，则默认基类为 Object 类

public class Person { ... }

等价于

public class Person extends Object { ... }

toString: 对象的字符串表示

equals:比较相等，默认地址比较(”第一个盒子的比较”)，要比较第二个 盒子需要重写

4、实例化过程

实例化一个类是从最顶级的超类开始实例化的, 是一层一层的包裹结构. “先父类后子类, 先静态后成员”。

public class F{ static{ System.out.println("父类静态块"); } { System.out.println("=========="); System.out.println("父类构造块"); } public F(){ System.out.println("父类构造器"); } } public class C extends F{ static{ System.out.println("子类静态块"); } { System.out.println("子类构造块"); } public C(){ //super(); System.out.println("子类构造器"); System.out.println("=========="); } }

5、super

子类中，使用 super 指代父类的信息(注意访问权限)，或者父类的构造器

public class Test { public static void main(String[] args) { new ChildClass().f(); } } class Father { public int value; public Father(){ } public Father(int a){ value =a; System.out.println("Father(int)"); } public void f(){ value = 100; System.out.println("Father.value="+value); } } class Child extends Father { public int value; public Child(){ super(12); } public void f() { super.f(); value = 200; System.out.println("Child.value="+value); System.out.println(value); System.out.println(super.value); } }

6、final

final 表示最终的。

修饰类，表示该类不能被继承

修饰方法，表示该方法不能被重写

修饰属性，表示常量，值一旦确定不可改变

class F{ public final String STR="bjsxt is very good"; //最终的方法 public final void test(){ System.out.println("f-->test()"); } } //最终的类 final class C extends F{ /* //此方法不能别重写 public void test(){ System.out.println("c-->test()"); } */ }/* class D extends C{ }*/