赞
踩
什么叫封装?
封装的本质是:类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员。从而让类调用者以更低的成本来使用类。
代码示例:
- class Student{
- private String name = "张三";
- private int age = 20;
-
- public void show(){
- System.out.println("姓名:"+name+" ,年龄:"+age);
- }
- }
- public class Demo1 {
- public static void main(String[] args) {
- Student student = new Student();
- student.show();
- }
- }
注意事项
代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法)
有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联
这时我们就需要引入父类 , 基类 或 超类和子类, 派生类,和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果,从而降低代码的冗余性。
继承的基本语法:
class 子类 extends 父类 {
}
我们来用代码实现一个继承关系:
- class Father{
- public String name;
- public int age;
- public char sex;
-
- public void eat(){
- System.out.println("吃饭");
- }
- }
-
- class Son extends Father{
- public void drink(){
- System.out.println("喝水");
- }
- }
-
- public class Demo1{
- public static void main(String[] args) {
- Son son = new Son();
- son.name = "张三";
- son.age = 20;
- son.sex = '男';
- son.eat();
- son.drink();
- }
- }
运行结果:
我们通过代码很容易看出来:当 Son 类继承了 Father 类后,就相当于把父类里的一些用 public 修饰过的属性和方法给拷贝过来了。
在上述代码中我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 "封装" 的初衷。所以我们就有个两全其美的办法:就是使用 protected 关键字。
final 关键字, 修饰一个变量或者字段的时候, 表示 常量 (不能修改)
final int a = 10;
a = 20; // 编译出错
final 关键字也能修饰类, 此时表示被修饰的类就不能被继承
当我们用 final 修饰 Father 类后,再想用 Son 类继承 Father 类就发生报错了
和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果 。
代码示例:
- class Student {
-
- }
- class Teacher {
-
- }
- class School {
- public Student[] students;
- public Teacher[] teachers;
- }
组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段.这是我们设计类的一种常用方式之一.
代码示例:
- class Father{
-
- }
- class Son extends Father{
-
- }
- public class Data {
- public static void main(String[] args) {
- Father f1 = new Father();
- }
- }
向上转型发生的时机:
直接赋值的方式我们已经演示了. 另外两种方式和直接赋值没有本质区别
代码示例:
- class Father{
-
- }
- class Son extends Father{
-
- }
- public class Data {
- public static void func(Father f1){
-
- }
- public static void main(String[] args) {
- func(new Son());
- }
- }
代码示例
- class Father{
-
- }
- class Son extends Father{
-
- }
- public class Data {
- public static Father func(){
- Son son = new Son();
- return son;
- }
- public static void main(String[] args) {
- Father f1 = func();
- }
- }
此时方法 func() 返回的是一个 Father 类型的引用, 但是实际上对应到 Son 的实例。
当子类和父类中出现同名方法的时候, 再去调用就会发生动态绑定。
- class Father{
- public String name;
- public int age;
- public void eat(){
- System.out.println("正在吃东西");
- }
- }
- class Son extends Father{
- public void eat(){
- System.out.println("正在吃苹果");
- }
- }
- public class Data {
- public static void main(String[] args) {
- Father f = new Son();
- f.eat();
- }
- }
此时, 我们发现:
因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定。
针对刚才的 eat 方法来说:子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为 覆写/重写/覆盖。
关于重写的注意事项:
重载和重写的区别:
有了面的向上转型, 动态绑定, 方法重写之后, 我们就可以使用 多态的形式来设计程序了.我们可以写一些只关注父类的代码, 就能够同时兼容各种子类的情况。
代码示例:打印各种形状
- class Shape{
- public void draw(){
- System.out.println("打印一个图形");
- }
- }
- class Rectangle extends Shape{
- @Override
- public void draw() {
- System.out.println("矩形");
- }
- }
- class Circle extends Shape{
- @Override
- public void draw() {
- System.out.println("圆形");
- }
- }
- class Flower extends Shape{
- @Override
- public void draw() {
- System.out.println("❀");
- }
- }
-
- public class Data{
- public static void stamp(Shape shape){
- shape.draw();
- }
- public static void main(String[] args) {
- stamp(new Rectangle());
- stamp(new Circle());
- stamp(new Flower());
- }
- }
运行结果:
多态顾名思义, 就是 "一个引用, 能表现出多种不同形态"
使用多态的好处是什么?
1) 类调用者对类的使用成本进一步降低
2) 能够降低代码的 "圈复杂度", 避免使用大量的 if - else
3) 可扩展能力更强
向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象. 相比于向上转型来说, 向下转型没那么常见,但是也有一定的用途.
代码示例:
- class Son extends Father{
- public void eat(){
- System.out.println(name + "正在吃东西");
- }
-
- public void haha(){
- System.out.println("haha");
- }
- }
-
- public class Data{
- public static void main(String[] args) {
- Father f2 = new Son();
- if(f2 instanceof Son){
- Son f3 = (Son)f2;
- f3.haha();
- }else{
- System.out.println("不能转型");
- }
- }
- }
如果我们用普通的向上转型的话,是无法使用除了与父类同名的方法外的任何方法,但是我们使用向下转型就可以使用。只是这样一般不安全,所以我们要使用 instanceof 来判断是否正确的引用了子类。
前面的代码中由于使用了重写机制, 调用到的是子类的方法. 如果需要在子类内部调用父类方法怎么办? 可以使用super 关键字。
代码示例:
- class Father{
- public String name;
- public int age = 20;
- public void eat(){
- System.out.println("正在吃东西");
- }
- }
- class Son extends Father{
- public int age = 30;
- public void func(){
- System.out.println(super.age);
- }
- }
- public class Data {
- public static void main(String[] args) {
- Son son = new Son();
- son.func();
- }
- }
我们可以看到在我们的子类和父类里都有属性 age ,当我们使用了 super 关键字后就可以访问父类的该属性。
运行结果:
super 和 this 的区别:
语法规则:
abstract class Shape {
abstract public void draw();
}
注意事项:
1) 抽象类不能直接实例化
Shape shape = new Shape();
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化
2) 抽象方法不能是 private 的
abstract class Shape {
abstract private void draw();
}
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private
3) 抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,也可以被子类直接调用
abstract class Shape {
abstract public void draw();
void func() {
System.out.println("func");
}
}
class Rect extends Shape {
...
}
抽象类的作用 :
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。