Java面向对象知识点归纳总结二（类间关系、Object类、抽象类、接口）

56 阅读 0 评论 37 点赞

我是靠谱客的博主冷静西装，最近开发中收集的这篇文章主要介绍Java面向对象知识点归纳总结二（类间关系、Object类、抽象类、接口），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1、类间关系
在面向对象的系统中，通常不会存在孤立的类，类之间、对象之间总是存在各种各样的关系，按照UML（Unified Modeling Language，统一建模语言）规范，类之间存在六种关系：继承、实现、依赖、关联、聚合、组成。

UML的六种关系中，继承和实现是一种纵向的关系，而其余四种是横向关系。其中关联、聚合、组成关系在代码上是无法区分的，更多的是一种语义上的区别。

继承
在Java中，被继承的类叫父类（parent class）或超类（super class），继承父类的类叫子类（subclass）或派生类（derived class）。

在Java中，关键字“extends”表示继承，后面紧跟父类的类名，如下：
public class Person {
private String name;// 姓名
private int age;// 年龄
private String gender;// 性别
……//省略get和set方法
}
class Teacher extends Person {
private float salary;// 薪酬
private String department;// 部门
……//省略get和set方法
}
class Student extends Person {
private int[] score;// 成绩
private String grade;// 年级
……//省略get和set方法
}
重写
当一个子类继承了一个父类时，可以在子类中直接使用父类的属性和方法。如果父类的方法无法满足子类的需求，则可以在子类中对父类的方法进行改造，也称作重写（override）。重写是Java多态性的另一种体现。

重写的原则

重写的方法的签名必须要和被重写的方法的签名完全匹配
重写的方法的返回值必须和被重写的方法的返回一致或者是其子类；
重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
私有方法不能被重写
子类重写父类方法的过程中，可访问性只能一样或变的更公开。
public class Base {
public void print() {
System.out.println("In Base ");
}
public static void main(String[] args) {
Son obj = new Son();
obj.print();
}
}
class Son extends Base {
// 覆盖父类的print()方法
public void print() {
System.out.println("In Son ");
}
}
//执行结果如下：
In Son
依赖关系
在一个类的方法中操作另外一个类的对象，则称其依赖于第二个类。
public class Person {
void travel( Car car ) {
car.run(“北京”);
}
public static void main(String[] args) {
new Person().travel( new Car() );
}
}
class Car {
void run(String city) {
System.out.println(“汽车开到” + city);
}
}
关联关系
体现为一个类中使用另一个类的对象作为属性。（子对象）
public class Person {
Car car;
Person(Car car) {
this.car = car;
}
void travel() {
car.run(“北京”);
}
public static void main(String[] args) {
new Person(new Car()).travel();
}
}
class Car {
void run(String city) {
System.out.println(“汽车开到” + city);
}
}
聚合关系
聚合关系体现的是整体与部分的关系，即一个类（整体）由其它类类型的属性（部分）构成。聚合关系中的各个部分可以具有独立的生命周期，部分可以属于多个整体。
public class Department {
Employee[] employees;
public static void main(String[] args) {
Employee e1 = new Employee();
Employee e2 = new Employee();
Employee e3 = new Employee();

	Department dept1 = new Department();
	dept1.employees = new Employee[] { e1, e3 };
	Department dept2 = new Department();
	dept2.employees = new Employee[] { e2, e3 };
}

}
class Employee {}
super
“super”关键字代表父类对象。通过使用super关键字，可以访问父类的属性或方法，也可以在子类构造方法中调用父类的构造方法，以便初始化从父类继承的属性。

final
用来修饰类、方法和变量，其含义是“不可改变的、最终的” 。
修饰类：声明为final的类不能被继承，一个final类中的所有方法都隐式地指定为final。
修饰变量：声明为final的变量是一个常量，在定义时必须给予初始值，变量一旦初始化，将不能改变。
修饰方法：声明为final的方法不能被子类重写。

2、Object类
概述
Object类是所有类的顶级父类，在Java体系中，所有类都是直接或间接的继承了Object类，Object类包含了所有Java类的公共属性和方法，这些属性和方法在任何类中均可以直接使用，其中较为重要的方法如下表所示：
在这里插入图片描述

注意：

继承是面向对象编程技术的基础，它允许创建分等级层次的类
任何类只能有一个父类，即Java只允许单继承
除构造方法，子类继承父类的所有方法和属性
overload（重载）是多态性的静态展示，override（重写）是多态性的动态展示
super有两种通用形式：调用父类的构造方法、用来访问被子类的成员覆盖的父类成员
final修饰符可应用于类、方法和变量
Object是所有类的最终父类，是Java类结构的基础
类之间有依赖、关联、聚合、组成四种关系
3、抽象类
定义
在面向对象的概念中，所有的对象都是通过类来表述，但并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一类具体的对象，这样的类就是抽象类。抽象类虽然具备类的形式，但由于其“抽象”性，不能定义抽象类的实例，即不能为抽象类分配具体空间；

抽象类需要注意以下几点：

abstract放在class前，指明该类是抽象类；
abstract放在方法声明中，则该方法是抽象方法，抽象方法没有方法体；
一个抽象类可以含有多个抽象方法，也可以含有已实现的方法。
抽象类不能实例化，但可以指向一个实现它的子类对象；
abstract不能与final同时修饰一个类；
abstract不能和static、private、final或native并列修饰同一方法。
使用
public abstract class Shape {
double dim;
public Shape(double dim) {
this.dim = dim;
}
// 抽象方法,获得面积
public abstract double callArea();
// 抽象方法，获得周长
public abstract double callPerimeter();
}
//可以通过如下方式来实例一个抽象类
Shape someShape;
//引用Circle类的实例对象
someShape = new Circle(5);
someShape.callArea();
4、接口
概述
Java是单继承的语言，利用接口可以模拟多继承；
接口是对抽象类的进一步抽象，是方法声明和常量的定义集合；
接口是一种行为规范，是一种契约；
定义
//定义接口格式
<访问符> interface 接口名 {
[访问符] <返回类型> 方法名([参数列表])；
…
}
注意：在定义接口的时候，接口中的所有方法和常量自动定义为public。接口中定义的变量默认是public static final 型，且必须赋初值
从JDK8.0开始可以使用default关键字来定义一个默认的方法来扩展接口，default关键字修饰的默认方法可以直接调用，不用子类去实现。
使用

//接口的使用通过“implements”关键字来实现
public class MyClass implements MyInterface {
public void add(int x, int y) {
// do something
}
public void volume(int x, int y, int z) {
// do something
}
}

//多重继承
public class MyClass2 implements MyInterface, MultiInterface{
…//实现多个接口中的所有方法
}
5、抽象类与接口区别
抽象类中可以有非抽象方法。JDK8.0之前接口中则不能有实现方法，之后可以使用default关键字来定义一个默认的方法；
接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值；
接口中的方法默认都是public abstract类型的。
6、instanceof运算符
声明为同种类型的两个引用变量调用同一个方法时也可能会有不同的行为。为更准确的鉴别一个对象的真正类型，Java语言引入了instanceof操作符，其使用格式如下：

<引用类型变量> instanceof <引用类型>

当 instanceof 左侧的引用类型变量所引用对象的实际类型是其右侧给出的类型或其子类类型时，整个表达式的结果为true，否则为false。

7、对象类型转换
自动转换
子类转换成父类时（或者实现类转换成接口）可以自动完成。例如，Teacher是Person的子类，将一个Teacher对象赋给一个Person类型的变量时，转换自动完成。

强制转换
父类转换成子类时（或者接口转换成实现类），必须使用强制转换。例如，Teacher类是Person的子类，如果将一个Person对象赋给一个Teacher类型变量的时候，必须使用强制转换。
//创建一个Teacher对象，把引用赋予Person类型的变量p，该过程自动转换
Person p = new Teacher();

//把变量p强制转换成Teacher类型的变量
Teacher t = (Teacher)p;