七.面向对象的思想(三)
七.面向对象的思想(三)
访问修饰符
基本介绍
java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:
1) 公开级别:用 public 修饰,对外公开
2) 受保护级别:用 protected 修饰,对子类和同一个包中的类公开
3) 默认级别:没有修饰符号,向同一个包的类公开.
4) 私有级别:用 private 修饰,只有类本身可以访问,不对外公开
访问修饰符的注意事项
1）修饰符可以用来修饰类中的属性，方法以及类
2）只有默认的和public才能修饰类！，并且遵循上述访问权限的特点
3）成员方法的访问规则和属性完全一样
面向对象的三大特性
1.封装
封装就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[方法]，才能对数据进行操作。
封装的好处：
1）隐藏实现细节
2）可以对数据进行验证，保证安全合理
封装的实现步骤：
1）将属性进行私有化private[不能直接修改属性]
2）提供一个公共的(public)set方法，用于对属性判断并赋值
3）提供一个公共的(public)get方法，用于获取属性的值
2.继承
继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中 抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来 声明继承父类即可。
继承的基本语法
class 子类 extends 父类{
}
1）子类会自动拥有父类定义的属性和方法
2）父类又叫超类，基类
3）子类又叫派生类
继承的深入讨论/细节问题
1) 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访 问，要通过父类提供公共的方法去访问
2) 子类必须调用父类的构造器， 完成父类的初始化
3) 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无 参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过
4) 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)
5) super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)
6) super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
7) java 所有类都是 Object 类的子类, Object 是所有类的基类.
8) 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)
9) 子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。 思考：如何让 A 类继承 B 类和 C 类？ 【A 继承 B， B 继承 C】 10) 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系。
super关键字：
super 代表父类的引用，用于访问父类的属性、方法、构造器
super基本用法
1.访问父类的属性，但不能访问父类的private属性 super.属性名
2.访问父类的方法，不能访问父类的private方法 super.方法名
3.访问父类的构造方法：super(参数列表)；只能放在构造器的第一句，只能出现一句！
super 和 this 的比较
方法重写/覆盖(override)
方法的覆写(重写)就是子类有一个方法，和父类的某个方法的名称，返回类型，参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
重写使用细节
1.子类的方法的参数列表，方法名称，要和父类方法的参数列表，方法名称完全一样。
2.子类方法的返回类型和父类的返回类型一样，或者子类的返回类型是父类返回类型的子类
3.子类方法不能缩小父类方法的访问权限
方法的重写和重载的区别
3.多态
方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。
多态的具体体现
重写和重载就体现多态
public class PloyMethod {
public static void main(String[] args) {
//方法重载体现多态
A a = new A();
//这里我们传入不同的参数，就会调用不同 sum 方法，就体现多态
System.out.println(a.sum(10, 20));
System.out.println(a.sum(10, 20, 30));
//方法重写体现多态
B b = new B();
a.say();
b.say();
}
}
class B { //父类
public void say() {
System.out.println("B say() 方法被调用...");
}
}
class A extends B {//子类
public int sum(int n1, int n2){//和下面 sum 构成重载
return n1 + n2;
}
public int sum(int n1, int n2, int n3){
return n1 + n2 + n3;
}
public void say() {
System.out.println("A say() 方法被调用...");
}
}
对象的多态：
1）一个对象的编译类型和运行类型可以不一致
2）编译类型在定义对象时，就确定了，不能改变
3）运行类型是可以改变的
4）编译类型看定义时 = 号的左边，运行类型看 = 号的右边
public class Animal {
public void cry() {
System.out.println("Animal cry() 动物在叫....");
}
}
public class Cat extends Animal {
public void cry() {
System.out.println("Cat cry() 小猫喵喵叫...");
}
}
public class Dog extends Animal
public void cry() {
System.out.println("Dog cry() 小狗汪汪叫...");
}
}
public class PolyObject {
public static void main(String[] args) {
//体验对象多态特点
//animal 编译类型就是 Animal , 运行类型 Dog
Animal animal = new Dog();
//因为运行时 , 执行到改行时，animal 运行类型是 Dog,所以 cry 就是 Dog 的 cry
animal.cry(); //小狗汪汪叫
//animal 编译类型 Animal,运行类型就是 Cat
animal = new Cat();
animal.cry(); //小猫喵喵叫
}
}
多态注意事项
多态的前提是：两个对象(类)存在继承关系
多态的向上转型
1）本质：父类的引用指向了子类的对象
2）语法：父类类型 引用名 = new 子类类型();
3）特点：编译类型看左边，运行类型看右边。
可以调用父类的所有成员(需要遵守访问权限)
不能调用子类中特有的成员、
最终运行效果看子类的具体实现！
多态的向下转型
1）语法：子类类型 引用名 = new 子类类型();
2）只能强转父类的引用，不能强转父类的对象
3）要求父类的引用必须指向的是当前目标类型的对象
4）当向下转型后，可以调用子类类型中所有的成员
java的动态绑定机制
1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
浙公网安备 33010602011771号