Java面向对象编程包含哪些内容？

怎么理解面向对象编程？

现实生活中，我们定义了“人”的抽象概念，这就是类class，生活中的每一个具体的人就是实例instance。

class就是一种模板，本身是一种数据类型。

instance是根据模板创建的对象，每一个模板可以创造不同的对象，且各个对象之间属性可以不同。

举个例子，左边的模子就是类class，右边的爱心鸡蛋就是实例instance。

class类似于C语言里面的struct结构体，可以封装一系列的变量（字段field），最终相当于一个新的数据结构。

用class新建出来的各个实例是互不干扰的，有各自的field，在访问的时候用变量名.字段的方法。

由于实例是通过class这个复杂数据结构创造出来的，为了节省内存，指向实例instance的变量都是引用类型的变量。

为什么需要方法？

一个类class里面通常有多个字段field（变量），如果把这些字段field直接暴露public出去，就会破坏【封装性】，容易出错。所以为了避免外部代码直接操作这些字段，在类里面通常使用private去保护，拒绝外部代码的访问。

但是这样又会产生一个新的问题，既然外部代码不能访问了，这些private field怎么操作呢？

因此可以在定义类class的同时，定义操作private field的方法method，这样外部代码就能通过method来间接修改private field的值。

使用方法method还可以带来一个好处，就是在方法内部，可以设置一个函数检查传递进来的参数是否正确，如果参数超出范围，可以直接抛出错误便于调试。

方法method也是可以被修饰成private的，只有这个类class内部的其他方法可以调用。

构造方法有什么用？

在创建普通变量的时候，我们经常会在新建变量的同时进行初始化，例如int age = 24，那么在创建实例instance的时候，能不能也同时初始化呢？

当然可以，不过这时候就需要用到构造方法。

构造方法的特点：

构造方法的名称和类的名称一样。
构造方法没有返回值，也没有void。
构造方法的调用，需要使用new关键字。
如果不写构造方法，编译器其实自动创建了一个空的构造方法。
一个类的构造方法可以有好几个，在调用的时候会根据参数自动匹配。
如果构造方法和类同时对一个字段field进行初始化，执行的时候是先执行类方法初始化，后执行构造方法初始化，所以最终以构造方法为准。

总结一句话，构造方法就相当于初始化一个结构体变量。

Person p = new Person("Xiao Ming", 15);

方法重载有什么用？

如果我们想定义一系列方法，他们的功能基本是一样的，但是不同的可选参数可以返回不同的结果，那么我们可以把这些方法合并成一个同名方法，这个就是方法重载overload。

例如之前提到的构造方法本质上就是一种方法重载，常见的字符串函数indexOf()函数也是一种方法重载。

方法重载的特点：

方法名称相同，返回类型也必须相同；
方法重载的参数不同。

继承有什么用？

比如我们新建了一个Person的类，里面包含age，name这些字段，以及相应的方法，接着我们又想创建一个Student和一个Teacher类，可不可以在Person的基础上直接改造呢？

当然是可以的，直接新建一个类，继承Person类，就可以了，省去了很多代码。

继承树

在Java中，所有的类都继承自Object类，形成如图所示的继承树。

在使用public class ***的时候，其实是对public class *** extends Object的省略，而在继承普通类的时候，就必须把extends ***写完整。

以Person和Student为例class Student extends Person {}：

Person有如下说法：超类super class，父类father class，基类base class
Student有如下说法：子类subclass，扩展类extended class

在继承的时候，子类就得到了父类所有的字段和方法，因此不能再出现和父类中同名的字段和方法！

protected关键字有什么用

如果在父类中所有的字段和方法都是private私有的，那么也就意味着连自己的儿子类都无法访问，这样继承还有什么意义呢？

既然父子都是一家人，所以一般父类中的字段和方法通常设为protected，向家里人公开但是防止别人过来侵占资产就行了，这就是protected。

protected修饰的字段和方法在整个家族中都是公开的，可以被子类，或者子类的子类（孙子）访问。

super关键字有什么用

super代表超类（父类），如果子类想引用父类中的字段和方法，就需要使用super关键字。

什么时候会用到super呢，或者说什么时候不得不用呢？

例如这段代码，构造了一个Person类，一个继承他的Student类，由于Person类中已经有name和age了，所以在Student中只添加score就行了，然后完成构造。

结果程序出错了，为什么？

class Student extends Person{public Student(String name，int age, int score){protected int score;// 构造方法public Student(String name, int age, int score){// super();    // 这个是系统自动添加的！！！this.score = score;}}
}
class Person{protected String name;protected int age;// 构造方法public Person(String name, int age){this.name = name;this.age  = age;}
}

注意！在line 6的地方，我们其实是什么都没写的，但是系统自动生成了super()这条语句帮我们继承父类，而父类中没有score这个字段，所以编译出错！

因此需要在line 6处手动增加这条：

super(String name, int age)

向上转型和向下转型是什么意思

结合继承树的上下关系理解，上面的Person是父亲，下面的Student是儿子。

向上转型，就是Student实例抽象成Person，相当于是丢掉score字段，因此这是可行的。
向下转型，因为Person中没有score字段，如何凭空变出score呢？所以这是不可行的。

final关键字

继承。final关键字表示自己不能被继承，是最后一代子孙了。
字段。final关键字修饰的字段，不能被修改，必须在创建实例instance的时候初始化。
方法。final关键字修饰的方法，也不能被覆写override。

什么是多态？

什么是覆写override，和重载overload有什么区别？

如果父类有一个方法，子类中也有一个相同的方法，这就是覆写override
如果在一个类中，有不同的方法，但是函数名相同，这就是重载overload
override只有一个方法，而overload其实是几个不同的方法（因为参数不同）

在使用override的时候，可以加上@Override，这样能借助编译器进行检查，注意要大写！

通过一段代码理解多态

public class Main {public static void main(String[] args) {Person p = new Student();    // 新建了一个Student类，但是向上转型，是一个Person引用p.run(); // 应该打印Person.run还是Student.run?}
}class Person {public void run() {System.out.println("Person.run");}
}class Student extends Person {@Overridepublic void run() {System.out.println("Student.run");}
}

line3中的Person p = new Student()到底是什么类？

Java的实例调用，和声明的类型无关，取决于实际运行时候的类型。

虽然p是一个指向Person类的引用，但实际指向的是Student实例，所以会打印出Student.run。

一个具体的应用多态的案例

public class Main {public static void main(String[] args) {// 给一个有普通收入、工资收入和享受国务院特殊津贴的小伙伴算税:// 定义了Income父类，然后把所有的子类都向上转型// 在Income后面直接加一个括号，就代表Income类的数组Income[] incomes = new Income[] {// 依然是需要new来调用构造方法new Income(3000),new Salary(7500),new StateCouncilSpecialAllowance(15000)};System.out.println(totalTax(incomes));}//  public static double totalTax(Income... incomes) { //这个写法也可以public static double totalTax(Income[] incomes) {double total = 0;for (Income income: incomes) {       // for each方法// 当incomes传进来的时候，总共有三种不同类型的income// 三种不同类型的income，对应三种不同的getTax()方法// getTax()方法是根据具体的income类型来调用各自的getTax()函数total = total + income.getTax();}return total;}
}class Income {protected double income;public Income(double income) {   //构造方法this.income = income;}public double getTax() {return income * 0.1; // 税率10%}
}class Salary extends Income {public Salary(double income) {super(income);}@Override // 让编译器帮助检查，注意O需要大写public double getTax() {if (income <= 5000) {return 0;}return (income - 5000) * 0.2;}
}class StateCouncilSpecialAllowance extends Income {public StateCouncilSpecialAllowance(double income) {super(income);}@Overridepublic double getTax() {return 0;}
}

在上面这段代码中，总共定了三种不同类class表示收入，并且分别都有各自的getTax函数。

主函数中新建了一个表示收入的数组，由于三个类class各不相同，但是同属于Income类，所以全部向上转型，统一用Income引用。

在主函数中调用totalTax，然后由totalTax调用getTax函数的时候，会自动根据不同的类class，调用相应的getTax函数，这个自动适应的特性，就是多态polymorphic。

抽象类有什么用？

如果我们定义了一个类class，但是没有具体的方法执行代码，这个方法就是抽象方法，同理，这个类就是抽象类，抽象用abstrac关键字修饰，例如：

abstract class Person{public abstract void run();    // 这里没有{}，没有具体的执行方法
}
class xiaoming extends Person{@Overridepublic void run(){}
}

空的方法，这种类有啥用呢？

这种类只能被继承，然后在子类中进行具体方法的覆写override，此时抽象类的作用就是提供一种编程规范。

这种编程方法也叫面向抽象编程。

把上面的税收计算器改成使用抽象类处理：

//自己设计一个计算税收的计算器，假定自己有三份收入来源
public class Main{public static void main(String[] args) {// 新建收入Income[] incomes = new Income[] {new Gongzi(8000),        // 这里要有逗号隔开！new Baiditan(2000),new Caipiao(3000)};                               // 这里需要一个分号！// 调用总收入System.out.println(getToatalIncome(incomes));// 调用总税收System.out.println(getTotalTax(incomes));}// 这个子函数要放在main函数外面的，main函数里面一定要加staticpublic static double getToatalIncome(Income[] incomes) {double total = 0;          // 这里不能加任何修饰符，为什么？for (Income income : incomes) {total = income.getIncome() + total;}return total;}public static double getTotalTax(Income[] incomes) {double totaltax = 0;for (Income income:incomes) {totaltax = totaltax + income.getTax();}return totaltax;}
}// 类的定义一定要放在Main这个class的外面
// 一个.java文件只能有一个public类，所以这里不能标记为public！
// 定义一个抽象的类
abstract class Income{// 字段是不能被修饰成abstract的，只有类和方法可以protected double money;public Income(double money){  // 构造方法不需要加abstractthis.money = money;}public abstract double getIncome(); // 抽象方法不需要加{}，直接以;结尾。public abstract double getTax();
}// 定义具体的类，两个抽象方法需要被覆写Override
class Gongzi extends Income{public Gongzi(double money) {super(money);}@Override                   // 注意，Override的O要大写！！！public double getIncome() {return money;}public double getTax() {if (money<5000) {return 0;}elsereturn (money-5000)*0.2;}
}class Baiditan extends Income{public Baiditan(double money) {super(money);}public double getIncome() {return money;}public double getTax() {return 0;}
}class Caipiao extends Income{public Caipiao(double money) {super(money);}public double getIncome() {return money;}public double getTax() {return money*0.2;}
}

最终输出结果为

13000.0
1200.0

接口和抽象类有什么区别？

如果一个抽象类abstract class中，不包含任何的字段field，只包含抽象方法，就可以改写为接口interface。

接口interface比抽象类还要抽象，不定义任何字段，只规定方法签名。

实现的区别implements

接口在具体使用时，使用implements关键字实现interface，而抽象类是使用extends关键字，例如：

interface Person(){void run();void getName();
}
class Student implements Person{@Overridepublic void run(){System.out.println("Student.run");}
}

单继承和多实现

一个具体的类class可以实现（严格意义上不是继承）多个接口interface，但是一个具体的类只能继承1个类。

class Student implements Person,Book{……
}

接口和接口的继承extends

一个接口也可以继承另一个接口，使用extends关键字继承，相当于对接口的扩展。

interface Person(){void run();void getName();
}
interface Student extends Person(){void getScore();
}

通过对接口的扩展，Student接口获得了3个抽象方法签名，其中2个继承获得。

这是Java集合类定义的一组接口和抽象类，箭头描述了继承关系

接口的default可以定义具体方法

抽象类中，可以有具体的字段，也可以有具体的方法。
接口中，不可以有具体的字段，但可以由具体的方法，通过default关键字实现。

default是一个修饰符，可以定义多个default方法，在实现接口的时候不需要再覆写override。

和抽象类中的具体方法有所不同

抽象类中的具体方法可以访问字段field
接口中的default方法不可以访问字段field

总结抽象类abstract class和接口interface的区别

static关键字有什么用？

每次在写main函数的时候，一般都会加上public static void这几个修饰符，那么这个static有什么用呢？

static修饰的main方法，不需要进行实例化就能调用的，属于一种工具函数，调用非常方便。

除此之外，static还有3种常见的应用：

修饰类class中的静态变量，使其变成一种共享变量，类似于其他语言的全局变量，一处改动处处都动，一般用于计数。
修饰接口interface中的静态字段，使得这个字段不需要经过实例化就能调用，类似于C语言中的# define标志符，一般在访问的时候通过class.field进行访问，而不是通过实例访问（虽然也能通过编译）。
修饰接口interface中的静态方法，使得这个方法不需要经过实例化就能调用。

共享变量number的图示如下，实际上number仅有一份，在instance中其实是不存在，通过ming.number（这种写法非常不好！）改变的是Person.number。

// static的使用
//1，修饰接口中的静态变量
//2，修饰静态方法，静态方法不需要创建实例就能使用
//3，main函数中的所有方法都是静态方法，因为main是不能被实例化的。
public class Main {public static void main(String[] args) {// 调用静态方法不需要创建实例Person.showName();// 调用接口中的静态变量，不需要创建时实例System.out.println(Person.MALE);System.out.println(Person.FEMALE);// 调用实例中的静态变量,会发现两个人的number永远是一样的，为什么？Student ming = new Student("xiaoming",23);Student hong = new Student("xiaohong",21);System.out.println(ming.number);System.out.println(hong.number);ming.number = 25;System.out.println(ming.number);System.out.println(hong.number);ming.number = 28;System.out.println(ming.number);System.out.println(hong.number);}
}interface Person{// 在接口中定义静态字段，用public static final三个修饰符同时修饰public static final int MALE = 1;// 在interface中，省略修饰符系统会自动添加int FEMALE = 2;// 静态方法public static void showName() {System.out.println("Hello");}
}class Student implements Person{// 在类中定义静态字段,这个字段是所有实例共享的public static int number = 18;private String name;private int age;public Student(String name, int age) {this.name = name;this.age  = age;}
}

包有什么用？

如果在团队合作中，每个人都写了一个Person包整合到项目中，怎么区分？

这时候就要引入包的概念了，每个人写的代码都装在他的书包里，需要的时候，从他的包package中取。

这有点类似于C++中命名空间namespace的概念，每个类都属于一个包，只是有些包可以默认不写，例如当前同一个package下的类，java.util里面的类。

所以包这个概念，非常适合团队协作管理，或者复杂一点的项目。

包的两种加载方式

import mr.jun.Arrays;    // 仅加载Arrays这个包
import mr.jun.*;        // 加载所有的包

一般不推荐下面这种方式，因为无法定位到到底使用了哪个包，容易造成逻辑混乱。

类的查找顺序

如果是完整的类名，则直接根据绝对位置查找
如果是简单的类名，按照如下顺序（这个和MATLAB非常像，先搜索当前目录，然后用户加载的目录，最后是去整个库函数中寻找）
1. 当前package
2. 加载import的package
3. java.lang（这个包不需要自己加载import，系统自动导入）

如何根据作用域选择4种修饰符？

在Java中，提供了4中内建的修饰符

public完全对外暴露，相当于外交，class，field，method都可以被其他类访问。
private权限只在类的内部，相当于内政，完全隐私。如果类中有嵌套类nested class，则也可以访问，相当于自己的老婆。一般private方法放在后面，因为大多数人看人先看脸，并不关注private。
protected价值在于继承，相当于家产和遗产，子子孙孙都享有。
package是自定义的一种作用域，对没有上面3种修饰符的类、字段、方法起限定作用，同一个包下可以互相访问，类似于朋友关系。

特殊的final修饰符

final修饰的class可以阻止被继承
final修饰的类中的field，或者局部变量可以组织被重新赋值
final修饰的类中的method可以防止被子类覆写

具体使用的一些注意点

如果不清楚是否需要public，能不写就不写
package有助于代码测试，测试代码和正式代码处于同一个文件夹即可拥有全部访问权限
一个.java中只能有一个对外public的class，其余的类不能声明为public

classpath、jar和模块有什么用？

classpath是存放class的位置

Java程序在运行的时候，其实是先编译成class文件，然后在JVM（Java Virtual Machine）中运行，那么JVM去哪里寻找class呢？

答案是classpath，他包括当前工程所在的目录，一些自定义的目录，以及系统的类目录。

classpath最好是在JVM运行时使用javac -cp手动设置，而不是在系统启动时设置。

用jar打包文件

怎么把这些散落各地的class组织起来打包呢？

用一个package包含所有的class，然后把这个package压缩成一个zip，后缀名改成jar就完事了。

因此这个jar就相当于对class的一个打包，或者说是class文件的目录。

都是打包，模块module和jar有什么区别

jar只是单纯地把一堆class打包在一起，而模块module还添加了class之间的依赖关系。

添加依赖有什么用呢？

Java标准库非常之大，许多程序并不需要这个完整的库，所以Java9把标准库拆分成了几十个模块，后缀名是.jmod，各个module之间有依赖关系，因此如果只选用部分module的话，就需要写入依赖关系。

怎么使用module？

先写一个声明依赖关系的文件module-info.java，写好依赖关系requires ABC，然后在需要的地方导入这个包import ABC。

在src文件下写入一个module-info.java文件，里面格式为：

module hello.world{          // module 是关键字，hello.world是模块的名字requires java.base;      // 这个是自动被引用的requires java.xml;      // 这个需要自己手动引用
}

在具体的函数中，需要声明package目录，然后导入module-info.java中依赖的包。

package com.itranswarp.sample;
import java.xml.XMLConstants;

模块的访问权限不够怎么办？

限定作用域的4种修饰符public，private，protected，package都只能在class内部作用，如果一个模块包含许多class，各个class之间如何互相访问呢，使用public可以吗？

public仍然只在类内有效，所以这里需要用exports把包导出。

具体方法是在module-info.java中使用exports package语句，例如：

module hello.world{                      // module 是关键字，hello.world是模块的名字exports com.itranswarp.sample;       // 把这个包导出来requires java.base;                   // 这个是自动被引用的requires java.xml;                  // 这个需要自己手动引用
}

Java面向对象基础学习笔记（构造、重载、继承、多态、抽象类、接口、模块）相关推荐

【Java】Java零基础学习笔记
文章目录前言思维导图前期准备卸载JDK 安装JDK Hello,world 可能遇到情况 java程序运行机制 IDEA的安装 java基础部分基础语法运算符包机制 javaDoc文档手 ...
继承多态抽象类接口
面向对象编程包继承组合多态抽象类接口包包(package)是组织类的一种方式. 使用包的主要目的是保证类的唯一性. java中已经提供给我们很多现成的类供我们选择,例如可以使用 imp ...
Java SE基础学习笔记2·面向对象
文章目录对象和类面向对象类类的定义步骤对象对象的使用定义数组对象数组对象内存图单个对象多个对象多个对象指向相同成员变量和局部变量封装 private 关键字被其他类使用 ...
大三Java SE基础学习笔记
Java及Java SE学习笔记前言主要用于记录学习过程中的一些笔记. 了解 JavaEE是指Java Enterprise Edition,Java企业版,多用于企业级开发,包括web开发等等, ...
（Java零基础学习笔记）第二章 Java中的基本语法
前言: 大家好! 我是BA unravel .如果你想和我一起学习JAVA,欢迎大家一起来学习这个世界上最好的语言! 学习目标: 一周掌握 Java 入门知识学习内容: 1. 搭建 Java 开发环 ...
Java web基础学习笔记
1.xml概述 1.1xml:xml一种数据存储格式,这种数据存储格式在存储数据内容的同时,还能够保存数据之间的关系 1.2xml保存数据的方法:xml利用标签来保存数据的内容,利用标签之间的嵌套关系 ...
C++学习笔记系列之继承多态
一.移动语义 1.右值引用有一种机制,可以在语法层面识别出临时对象,在使用临时对象构造新对象(拷贝构造)的时候,将临时对象所持有的资源『转移』到新的对象中,就能消除这种不必要的拷贝. 2. ...
Java SE基础学习笔记1·基础
文章目录 Java 特点 Java语言跨平台原理 JRE 和 JDK JDK的下载和安装常用DOS命令配置Path环境变量 Java程序开发运行流程基础语法注释关键字标识符小驼峰命名法: ...
java—面向对象【学习笔记2】
目录构造方法 this关键字 static关键字 java中类成员在构造(对象创建的时候)的调用顺序构造方法 ...

Java面向对象基础学习笔记（构造、重载、继承、多态、抽象类、接口、模块）