Java面向对象总结

最新推荐文章于 2024-01-24 11:01:41 发布

fly-liuhao

最新推荐文章于 2024-01-24 11:01:41 发布

阅读量346

点赞数 2

分类专栏： Java 文章标签： Java 面向对象

本文链接：https://blog.csdn.net/Fly_1213/article/details/90448770

版权

Java 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

面向对象特性

封装
继承
多态
抽象

封装的目的：保护数据
继承的目的：类的复用
多态的目的：增强程序的复用性，解耦
抽象的目的：被子类继承，实现类的复用

访问控制

访问控制：控制类外面可以访问类中的那些属性和方法；

访问控制符号：用于修饰属性和方法/（类）

修饰符	本类内部	同包中的类	子类	包外其它类
public	可以访问	可以访问	可以访问	可以访问
protected	可以访问	可以访问	可以访问	不能访问
默认	可以访问	可以访问	不能访问	不能访问
private	可以访问	不能访问	不能访问	不能访问

访问控制符修饰类：

对于类的修饰可以使用public和默认（default）方式；
public修饰的类可以被任何一个类使用；
默认的访问控制的类只能被同包中的类使用；

封装

什么是封装：就是将数据和对数据的操作集中的定义在对象中，外界仅能通过对象提供的接口访问对象的属性和功能;
- 属性私有(private)
- 提供公共方法访问(public)
封装的意义：对外提供可调用的、稳定的功能；
封装内部具体的实现细节，外界不可访问，这样的好处在于：降低出错的可能性；
内部变化，不会影响外部使用；

继承

什么是继承：类的复用—即使用现有类的定义复制并扩展出另一个新的类定义，子类可以继承父类中的成员变量和成员方法(不包含构造)，同时也可以定义自己的成员变量和成员方法；

泛化：从多个类中，抽取相同部分，生成父类的过程叫做泛化；
设计时，从子类泛化出公共父类，再让子类继承父类；
Java语言不支持多重继承，一个类只能继承一个父类，但一个父类可以有多个子类；

继承的语法规则？extends

Class Person {
  //...
}
Class Student extends Person {
  //...
}

继承要求：取决于父类的访问控制符

同一包中继承：子类可以访问父类访问控制符为：public、protected、以及默认（default）的属性即方法；
跨包继承：默认情况下，只要不在一个包内，即使是继承也无法访问父类的默认访问控制的属性及其方法
- 类中访问：
  若子类需要访问父类属性或方法：要求父类属性及方法访问权限最低要是protected（public、protected）;
- 类外访问：
  子类对象只能直接访问子类从父类继承的访问控制符为【public】的属性或方法；
  若子类需要访问父类中protected修饰的方法：子类需要使用重写通过super来调用父类的方法；
  (java中规定：子类重写父类的方法，子类的方法访问控制范围不能小于父类方法的访问控制范围)

继承关系下，父类的构造方法调用问题？

创建子类对象的时候，父类的默认构造方法会默认调用
父类没有构造方法时，子类的构造函数需要使用super()指定父类的构造方法
super()必须放在子类构造方法的第一行

对象的构造次序如何？

继承关系是自下而上—子类继承于父类
构造函数调用是自上而下—先完成父类的构造，再完成子类的构造

方法的重写（Override）：

原因：继承于父类的方法无法满足子类的需要
方法名、参数列表（数据类型、个数、次序）、返回值类型相同，访问控制相同或者更加宽泛
父类构造方法不能被继承，所以不能被重写

@Override : 断言机制。就是告诉编译器当前方法是重写父类方法，
请编译器协助检查方法签名，如果重写的方法签名在父类中没有找到，则编译错误；

方法的重载（Overload）：一个类中有多个同名方法

规则：方法名字相同，参数列表必须不同，返回值和访问控制符不限
构造方法可以重载

this的使用：

this表示当前类的对象
使用this()调用本类自己的构造方法
this.(属性/方法),调用本类的属性和一般方法

shper的使用：

super表示父类的对象
使用super()调用父类的构造方法
使用super.(属性/方法)，在子类中调用父类的属性和一般方法

this()和supr()不能同时调用，都需要放在构造方法体的首行

创建子类对象时，程序执行过程?

父子类当中只有无参构造方法：先执行父类构造后执行子类构造
父类子类中属性赋值动作，赋值也是先赋值完父类的属性值，再赋值子类的属性，代码执行时先给属性赋值，再执行方法。
父子类有游离块：看代码位置

属性赋值顺序：隐式初值–>显示赋值–>构造赋值

父类的引用指向子类的对象

父类的引用可以指向子类的对象，但通过父类的引用只能访问父类自己定义的属性和功能部分（包含子类重写父类的方法），不能访问子类扩展的部分（独有的属性和功能）
例如Person类型的对象，就无法访问子类Student的成绩这个属性

动态方法调度

在运行时，父类变量根据指向子类对象的不同，动态判断调用何种重写方法

/*动态方法调度*/
Person dad = null;
Child1 = son1 = new Child1();
Child2 = son2 = new Child2();

//爸爸和大儿子一起做蛋炒饭
dad = son1;
dad.cook;

//爸爸和二儿子一起包饺子
dad = son2;
dad.cook;

笔试题（重写和重载的区别&&父类的引用指向子类的对象）

//下面代码输出结果是？
class Super {
    public void f() {
        System.out.println("super.f()");
    }
}

class Sub extends Super {
    public void f() {
        System.out.println("sub.f()");
    }
}

class Goo {
    public void g(Super obj) {
        System.out.println("g(Super)");
        obj.f();
    }

    public void g(Sub obj) {
        System.out.println("g(Sub)");
    }
}
class Test{
    public static void main(String[] args) {
        Super obj = new Sub();
        Goo goo = new Goo();
        goo.g(obj);
    }
}


//结果
g(Super)
sub.f()
/*
注意：如果父类Super中没有f()方法，那么这道题的输出结果就是编译错误；
原因是：父类中没有f()方法，子类中的f()方法就不是重写，所以父类定义的引用变量obj就不能访问子类的成员方法/（非重写方法）！
*/

抽象

抽象类、抽象方法

抽象类就是仅定义所有子类共享的形式，而没有定义具体实现细节的父类
抽象类中，那些只有方法的定义，没有实现细节(没有方法体)的方法叫做抽象方法；
一个类中如果包含抽象方法，该类应用abstract关键字声明为抽象类；
如果一个类继承了抽象类，必须重写其抽象方法（除非该类也声明为抽象类），且不同的子类可以有不同的实现。

语法：（被abstract修饰）

// 抽象类
public abstract class 类名 {
    // class boby

    // 抽象方法
    访问修饰符 abstract 返回值类型 方法名();
}

抽象类不能实例化

抽象类不可以实例化，因为抽象类是不完整的，要想使用抽象类中的普通方法，只能通过子类对象继承后调用；
```
Father father =  new Father();//编译错误
```
另外，即使一个类中没有抽象方法，也可以使用abstract修饰类。作用就是不让该类实例化；
abstract VS final
□ 抽象类：天生就用来被继承！不继承，就没有任何意义。
□ final：专门用来禁止被继承！和抽象类的意义刚好相反！

高内聚低耦合:在一个模块内部
23中设计模式*********************************************

接口

（一）、定义一个接口

接口是一个标准
接口是引用类型之一；（类、数组、接口）
接口的作用是：解耦，降低耦合,便于维护。
接口是一组方法定义的集合，但所有方法没有实现(默认)；

JDK1.8之后，接口中的方法可以有方法体（被default,static修饰的方法）
链接

接口天生用来被继承，不能被实例化；

语法：

public interface 接口名{
    public abstract 返回值类型 方法名()；
}
//public abstract 可以省略，编译器会自动补全；

（二）、实现一个接口

一个类可以通过implements关键字“实现”接口，称为：实现类；

语法：

public class 实现类类名 implements 接口名{
    //class boby
}

一个类要实现某个接口，就必须实现该接口中定义的所有抽象方法；
因为接口中的方法都是public修饰的，所以子类实现接口的方法时，也必须显示定义public访问修饰；
实现类可以实现多个接口，该类需要实现所有接口中定义的所有方法；；

（三）、接口的继承

接口间可以存在继承关系，一个接口可以通过extends关键字继承另外一个接口。子接口继承了父接口中定义的所有方法。
接口支持多继承，一个接口可继承多个接口；

（四）、继承父类与实现接口

一个普通的类可以继承一个类的同时再实现若干接口。

语法：(强调先继承（extends）再实现接口（implements）,不能颠倒！)

public class 子类名 extends 父类名 implements 接口 {
    // class body
}

（五)、动态调用接口方法

接口可以作为一种特殊类型声明一个引用类型的变量。
```
IUnionPay atm;//编译正确
```
一个接口类型的变量可以引用实现了该接口的类的对象。
因为可以动态调度，所以可以使用接口类型引用实现类的变量；
```
IUnionPay atm = newATMCBC();
IUnionPay atm = new ATMABC();
```

通过接口类型变量仅能调用实现该接口的类中重写的方法。

atm.drawMoney(3000);//本质，父类型的引用，可以调用子类型重载的方法；
atm.takePic();//编译错误：因为是子类重写别的接口的方法,不是重写当前IUnionPay接口的，所以不能调用。

（六）、接口中定义常量

接口中除了抽象方法外，只能定义“常量”。
编译器会自动增加public static final 修饰。
何时在接口中定义常量：一般用于实现类中引用固定的备选项。
比如：银联规定只能支持CBC,ABC两家银行的银行卡，不支持其它银行的银行卡。
在接口中定义常量，必须声明的同时初始化。

（七）、接口和抽象类的异同点：

1. 相同点

天生都是被继承的。不能实例化对象
一个类无论是实现接口还是继承抽象类，都必须实现其中所有的抽象方法。
接口和抽象类都可以声明父类型的变量，引用子类型对象
父类型对象的引用都可以调用子类型对象中重写的方法

切记：父类型对象的引用都不能调用子类型对象中非重写的方法

因为以上两点，所以抽象类和接口，都可以实现动态创建对象，和动态方法调度

2. 不同点

抽象类不允许多继承，而接口可以多继承
使用场景不同：
抽象类：主要用于封装子类中共享的成员。只有个别方法自己不能实现，才能定义抽象方法，请子类自力更生自己实现
接口：主要用于在程序中定义标准。接口完全不实现任何方法
成员的修饰词不同
抽象类中的成员，可以使用任何关键字修饰
接口中的成员变量都是public static final 的，方法都是public abstract的

fly-liuhao

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象总结

面向对象特性封装继承多态抽象封装的目的：保护数据继承的目的：类的复用多态的目的：增强程序的复用性，解耦抽象的目的：被子类继承，实现类的复用访问控制访问控制：控制类外面可以访问类中的那些属性和方法；访问控制符号：用于修饰属性和方法/（类）修饰符本类内部同包中的类子类包外其它类public可以访问可以访问可以访问可以访问...
复制链接

扫一扫

专栏目录