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

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的时候，能不能也同时初始化呢？

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

构造方法的特点：

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

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

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

方法重载有什么用？

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

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

方法重载的特点：

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

继承有什么用？

比如我们新建了一个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 {
    @Override
    public 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);
    }
    @Override
    public 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{
    @Override
    public 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函数里面一定要加static
	public 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){	// 构造方法不需要加abstract
		this.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;
		}
		else
			return (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{
    @Override
    public 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.*;		// 加载所有的包

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

类的查找顺序

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

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

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

1. public完全对外暴露，相当于外交，class，field，method都可以被其他类访问。
2. private权限只在类的内部，相当于内政，完全隐私。如果类中有嵌套类nested class，则也可以访问，相当于自己的老婆。一般private方法放在后面，因为大多数人看人先看脸，并不关注private。
3. protected价值在于继承，相当于家产和遗产，子子孙孙都享有。
4. 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。

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

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

2. 在具体的函数中，需要声明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;					// 这个需要自己手动引用
}