|
面向对象编程，顾名思义，你得首先有个对象； 有了对象后，就可以和对象进行互动； 是一种通过对象的方式，把现实世界映射到计算机模型的一种编程方法。 |
目录
一、方法
二、构造方法
三、方法重载
四、继承
五、多态
六、抽象类
七、接口
八、静态字段和静态方法
九、包
十、作用域
十一、内部类
十二、classpath和jar
十三、模块
一、方法
返回顶部目录1、定义方法
修饰符 方法返回类型 方法名(方法参数列表) {
若干方法语句;
return 方法返回值;
}
方法返回值通过return语句实现，如果没有返回值，返回类型设置为void，可以省略return。
2、private
private修饰的方法和字段都只能在本类中起作用
通常我们会用private修饰字段，用非private修饰的方法去间接访问本类中的字段
3、this变量
在方法内部，可以使用一个隐含的变量this，它始终指向当前实例。因此，通过this.field就可以访问当前实例的字段。
class Person {
private String name;
public void setName(String name) {
this.name = name; // 前面的this不可少，少了就变成局部变量name了
}
}
二、构造方法
返回顶部目录创建实例的时候，实际上是通过构造方法来初始化实例的。我们先来定义一个构造方法，能在创建Person实例的时候，一次性传入name和age，完成初始化：
public class Main {
public static void main(String[] args) {
Person p = new Person("Xiao Ming", 15);
System.out.println(p.getName());
System.out.println(p.getAge());
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}
如果一个类没有定义构造方法，编译器会自动为我们生成一个默认构造方法，它没有参数，也没有执行语句，类似这样：
class Person {
public Person() {
}
}
三、方法重载
返回顶部目录在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同，那么，可以把这一组方法名做成同名方法。例如，在Hello类中，定义多个hello()方法：
class Hello {
public void hello() {
System.out.println("Hello, world!");
}
public void hello(String name) {
System.out.println("Hello, " + name + "!");
}
public void hello(String name, int age) {
if (age < 18) {
System.out.println("Hi, " + name + "!");
} else {
System.out.println("Hello, " + name + "!");
}
}
}
这种方法名相同，但各自的参数不同，称为方法重载（Overload）。
四、继承
返回顶部目录通过继承，只需要编写额外的功能，不再需要重复代码。
注意：子类自动获得了父类的所有字段，严禁定义与父类重名的 字段！1、继承树
在Java中，没有明确写extends的类，编译器会自动加上extends Object。所以，任何类，除了Object，都会继承自某个类。
Java只允许一个class继承自一个类，因此，一个类有且仅有一个父类。只有Object特殊，它没有父类。
2、protected
继承有个特点，就是子类无法访问父类的private字段或者private方法。例如，Student类就无法访问Person类的name和age字段：
class Person {
private String name;
private int age;
}
class Student extends Person {
public String hello() {
return "Hello, " + name; // 编译错误：无法访问name字段
}
}
这使得继承的作用被削弱了。为了让子类可以访问父类的字段，我们需要把private改为protected。用protected修饰的字段可以被子类访问：
class Person {
protected String name;
protected int age;
}
class Student extends Person {
public String hello() {
return "Hello, " + name; // OK!
}
}
因此，protected关键字可以把字段和方法的访问权限控制在继承树内部，一个protected字段和方法可以被其子类，以及子类的子类所访问。
3、super
super关键字表示父类（超类）。子类引用父类的字段时，可以用super.fieldName。例如：
class Student extends Person {
public String hello() {
return "Hello, " + super.name;
}
}
实际上，这里使用super.name，或者this.name，或者name，效果都是一样的。编译器会自动定位到父类的name字段。
但是，在某些时候，就必须使用super。我们来看一个例子：
public class Main {
public static void main(String[] args) {
Student s = new Student("Xiao Ming", 12, 89);
}
}
class Person {
protected String name;
protected int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
class Student extends Person {
protected int score;
public Student(String name, int age, int score) {
this.score = score;
}
}
运行上面的代码，会得到一个编译错误，大意是在Student的构造方法中，无法调用Person的构造方法。
这是因为在Java中，任何class的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句super();，所以，Student类的构造方法实际上是这样：
class Student extends Person {
protected int score;
public Student(String name, int age, int score) {
super(); // 自动调用父类的构造方法
this.score = score;
}
}
但是，Person类并没有无参数的构造方法，因此，编译失败。
解决方法是调用Person类存在的某个构造方法。例如：
class Student extends Person {
protected int score;
public Student(String name, int age, int score) {
super(name, age); // 调用父类的构造方法Person(String, int)
this.score = score;
}
}
因此我们得出结论：如果父类没有默认的构造方法，子类就必须显式调用super()并给出参数以便让编译器定位到父类的一个合适的构造方法。
这里还顺带引出了另一个问题：即子类不会继承任何父类的构造方法。子类默认的构造方法是编译器自动生成的，不是继承的。
4、阻止继承
正常情况下，只要某个class没有final修饰符，那么任何类都可以从该class继承。
从Java 15开始，允许使用sealed修饰class，并通过permits明确写出能够从该class继承的子类名称。
例如，定义一个Shape类：
public sealed class Shape permits Rect, Circle, Triangle {
...
}
上述Shape类就是一个sealed类，它只允许指定的3个类继承它。
5、向上转型
继承树 Student > Person > Object
Person p = new Student(); // ???
Student继承自Person，因此，它拥有Person的全部功能。Person类型的变量，如果指向Student类型的实例，对它进行操作，是没有问题的！
这种把一个子类类型安全地变为父类类型的赋值，被称为向上转型（upcasting）。
向上转型实际上是把一个子类型安全地变为更加抽象的父类型
6、向下转型
和向上转型相反，如果把一个父类类型强制转型为子类类型，就是向下转型（downcasting）。例如：
Person p1 = new Student(); // upcasting, ok
Person p2 = new Person();
Student s1 = (Student) p1; // ok
Student s2 = (Student) p2; // runtime error! ClassCastException!
如果测试上面的代码，可以发现：
Person类型p1实际指向Student实例，Person类型变量p2实际指向Person实例。在向下转型的时候，把p1转型为Student会成功，因为p1确实指向Student实例，把p2转型为Student会失败，因为p2的实际类型是Person，不能把父类变为子类，因为子类功能比父类多，多的功能无法凭空变出来。
因此，向下转型很可能会失败。失败的时候，Java虚拟机会报ClassCastException。
和向上转型相反，如果把一个父类类型强制转型为子类类型，就是向下转型（downcasting）
为了避免向下转型出错，Java提供了instanceof操作符，instanceof实际上判断一个变量所指向的实例是否是指定类型，或者这个类型的子类。如果一个引用变量为null，那么对任何instanceof的判断都为false。
利用instanceof，在向下转型前可以先判断：
Person p = new Student();
if (p instanceof Student) {
// 只有判断成功才会向下转型:
Student s = (Student) p; // 一定会成功
}
从Java 14开始，判断instanceof后，可以直接转型为指定变量，避免再次强制转型。例如，对于以下代码：
Object obj = "hello";
if (obj instanceof String) {
String s = (String) obj;
System.out.println(s.toUpperCase());
}
7、继承和组合
Student可以持有一个Book实例，而不是继承于Book，Student应该继承于Person：
class Student extends Person {
protected Book book;
protected int score;
}
8、方法重写规则
1、父子类的方法名相同
2、父子类的方法参数列表相同（数量、位置、数据类型、参数名不做要求）
3、子类方法的返回值与父类方法的返回值类型相同或者是其子类
4、子类方法的访问权限不能小于父类
public>protected>默认>private
五、多态
返回顶部目录一个事物有多种表现形态，就是多态。
定义一个方法，在具体的生产环境中根据不同的需求呈现出不同的业务逻辑。
业务：书店会员买书，普通会员和超级会员优惠力度不同
package com.test3;
public class OrdinaryMember {
public void buyBook(){
System.out.println("普通会员买书打9折");
}
}
package com.test3;
public class SuperMember {
public void buyBook(){
System.out.println("超级会员买书打6折");
}
}
package com.test3;
public class Cashier {
private SuperMember superMember;
public SuperMember getSuperMember() {
return superMember;
}
public void setSuperMember(SuperMember superMember) {
this.superMember = superMember;
}
public void settlement(){
System.out.println("买单");
this.superMember.buyBook();
}
}
package com.test3;
public class Test {
public static void main(String[] args) {
SuperMember superMember = new SuperMember();
Cashier cashier = new Cashier();
cashier.setSuperMember(superMember);
cashier.settlement();
}
}
使用多态进行修改
package com.test3;
public class Member {
public void buyBook(){
}
}
package com.test3;
public class Cashier {
private Member member;
public Member getMember() {
return member;
}
public void setMember(Member member) {
this.member = member;
}
public void settlement(){
System.out.println("买单");
this.member.buyBook();
}
}
package com.test3;
public class Test {
public static void main(String[] args) {
// OrdinaryMember member = new OrdinaryMember();
// SuperMember member = new SuperMember();
VIPMember member = new VIPMember();
Cashier cashier = new Cashier();
cashier.setMember(member);
cashier.settlement();
}
}
继承是多态的基础，代码内部写的是父类类型，真正使用的时候传入的是子类对象。
多态的使用
1、定义方法时形参为父类类型，调用方法时传入的参数为子类对象。
public class Cashier {
public void settlement(Member member){
System.out.println("买单");
member.buyBook();
}
}
Member member = new VIPMember();
Cashier cashier = new Cashier();
cashier.settlement(member);
2、定义方法时返回值类型为父类，调用方法时返回子类对象。
public Member getMember(String name){
if(name.equals("ordinaryMember")){
return new OrdinaryMember();
}else{
return new SuperMember();
}
}
Cashier cashier = new Cashier();
System.out.println(cashier.getMember("ordinaryMember"));
System.out.println(cashier.getMember("superMember"));
六、抽象类
返回顶部目录没有方法体的方法叫做抽象方法，声明抽象方法需要添加 abstract 关键字。
public abstract void buyBook();
一旦类中定义了抽象方法，则该类也必须声明为抽象类，在类定义处添加 abstract 关键字。
public abstract class Member {
public abstract void buyBook();
}
抽象类和普通类的区别是抽象类不能被实例化，抽象方法和普通方法的区别是抽象方法没有方法体。
抽象类中可以没有抽象方法，但是包含了抽象方法的类必须是抽象类。
多态是一种编程思想，类中定义一个抽象的概念，对其进行编程，实际使用的时候根据不同的情况，赋予不同的具体对象，从而完成不同的业务，这就是多态的思想。
抽象类和抽象方法是用来实现多态的具体形式，抽象的概念就是抽象类，抽象方法就是抽象类中需要被子类重写的方法。
面向对象编程的特征：封装、继承、多态、抽象
七、接口
返回顶部目录在抽象类中，抽象方法本质上是定义接口规范：即规定高层类的接口，从而保证所有子类都有相同的接口实现，这样，多态就能发挥出威力。
如果一个抽象类没有字段，所有方法全部都是抽象方法：
abstract class Person {
public abstract void run();
public abstract String getName();
}
就可以把该抽象类改写为接口：interface。
在Java中，使用interface可以声明一个接口：
interface Person {
void run();
String getName();
}
所谓interface，就是比抽象类还要抽象的纯抽象接口，因为它连字段都不能有。因为接口定义的所有方法默认都是public abstract的，所以这两个修饰符不需要写出来（写不写效果都一样）。
当一个具体的class去实现一个interface时，需要使用implements关键字。举个例子：
class Student implements Person {
private String name;
public Student(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println(this.name + " run");
}
@Override
public String getName() {
return this.name;
}
}
我们知道，在Java中，一个类只能继承自另一个类，不能从多个类继承。但是，一个类可以实现多个interface，例如：
class Student implements Person, Hello { // 实现了两个interface
}
八、静态字段和静态方法
返回顶部目录1、静态字段
实例字段在每个实例中都有自己的一个独立“空间”，但是静态字段只有一个共享“空间”，所有实例都会共享该字段。举个例子：
class Person {
public String name;
public int age;
// 定义静态字段number:
public static int number;
}
我们来看看下面的代码：
public class Main {
public static void main(String[] args) {
Person ming = new Person("Xiao Ming", 12);
Person hong = new Person("Xiao Hong", 15);
ming.number = 88;
System.out.println(hong.number);
hong.number = 99;
System.out.println(ming.number);
}
}
class Person {
public String name;
public int age;
public static int number;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
对于静态字段，无论修改哪个实例的静态字段，效果都是一样的：所有实例的静态字段都被修改了，原因是静态字段并不属于实例：
虽然实例可以访问静态字段，但是它们指向的其实都是Person class的静态字段。所以，所有实例共享一个静态字段。
因此，不推荐用实例变量.静态字段去访问静态字段，因为在Java程序中，实例对象并没有静态字段。在代码中，实例对象能访问静态字段只是因为编译器可以根据实例类型自动转换为类名.静态字段来访问静态对象。
推荐用类名来访问静态字段。可以把静态字段理解为描述class本身的字段（非实例字段）。对于上面的代码，更好的写法是：
Person.number = 99;
System.out.println(Person.number);
2、静态方法
有静态字段，就有静态方法。用static修饰的方法称为静态方法。
调用实例方法必须通过一个实例变量，而调用静态方法则不需要实例变量，通过类名就可以调用。静态方法类似其它编程语言的函数。例如：
public class Main {
public static void main(String[] args) {
Person.setNumber(99);
System.out.println(Person.number);
}
}
class Person {
public static int number;
public static void setNumber(int value) {
number = value;
}
}
因为静态方法属于class而不属于实例，因此，静态方法内部，无法访问this变量，也无法访问实例字段，它只能访问静态字段。
通过实例变量也可以调用静态方法，但这只是编译器自动帮我们把实例改写成类名而已。
通常情况下，通过实例变量访问静态字段和静态方法，会得到一个编译警告。
静态方法经常用于工具类。例如：
Arrays.sort()
Math.random()
静态方法也经常用于辅助方法。注意到Java程序的入口main()也是静态方法。
3、接口的静态字段
因为interface是一个纯抽象类，所以它不能定义实例字段。但是，interface是可以有静态字段的，并且静态字段必须为final类型：
public interface Person {
public static final int MALE = 1;
public static final int FEMALE = 2;
}
实际上，因为interface的字段只能是public static final类型，所以我们可以把这些修饰符都去掉，上述代码可以简写为：
public interface Person {
// 编译器会自动加上public statc final:
int MALE = 1;
int FEMALE = 2;
}
编译器会自动把该字段变为public static final类型。
九、包
返回顶部目录Java内建的package机制是为了避免class命名冲突；
JDK的核心类使用java.lang包，编译器会自动导入；
JDK的其它常用类定义在java.util.，java.math.，java.text.*，……；
包名推荐使用倒置的域名，例如org.apache。
十、作用域
返回顶部目录 Java内建的访问权限包括public、protected、private和package权限；Java在方法内部定义的变量是局部变量，局部变量的作用域从变量声明开始，到一个块结束；
final修饰符不是访问权限，它可以修饰class、field和method；
一个.java文件只能包含一个public类，但可以包含多个非public类。
十一、内部类
返回顶部目录1、Inner Class
如果一个类定义在另一个类的内部，这个类就是Inner Class：
class Outer {
class Inner {
// 定义了一个Inner Class
}
}
上述定义的Outer是一个普通类，而Inner是一个Inner Class，它与普通类有个最大的不同，就是Inner Class的实例不能单独存在，必须依附于一个Outer Class的实例。示例代码如下：
public class Main {
public static void main(String[] args) {
Outer outer = new Outer("Nested"); // 实例化一个Outer
Outer.Inner inner = outer.new Inner(); // 实例化一个Inner
inner.hello();
}
}
class Outer {
private String name;
Outer(String name) {
this.name = name;
}
class Inner {
void hello() {
System.out.println("Hello, " + Outer.this.name);
}
}
}
观察上述代码，要实例化一个Inner，我们必须首先创建一个Outer的实例，然后，调用Outer实例的new来创建Inner实例：
Outer.Inner inner = outer.new Inner();
这是因为Inner Class除了有一个this指向它自己，还隐含地持有一个Outer Class实例，可以用Outer.this访问这个实例。所以，实例化一个Inner Class不能脱离Outer实例。
Inner Class和普通Class相比，除了能引用Outer实例外，还有一个额外的“特权”，就是可以修改Outer Class的private字段，因为Inner Class的作用域在Outer Class内部，所以能访问Outer Class的private字段和方法。
观察Java编译器编译后的.class文件可以发现，Outer类被编译为Outer.class，而Inner类被编译为Outer$Inner.class。
2、Anonymous Class
还有一种定义Inner Class的方法，它不需要在Outer Class中明确地定义这个Class，而是在方法内部，通过匿名类（Anonymous Class）来定义。示例代码如下：
public class Main {
public static void main(String[] args) {
Outer outer = new Outer("Nested");
outer.asyncHello();
}
}
class Outer {
private String name;
Outer(String name) {
this.name = name;
}
void asyncHello() {
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Hello, " + Outer.this.name);
}
};
new Thread(r).start();
}
}
观察asyncHello()方法，我们在方法内部实例化了一个Runnable。Runnable本身是接口，接口是不能实例化的，所以这里实际上是定义了一个实现了Runnable接口的匿名类，并且通过new实例化该匿名类，然后转型为Runnable。在定义匿名类的时候就必须实例化它，定义匿名类的写法如下：
Runnable r = new Runnable() {
// 实现必要的抽象方法...
};
匿名类和Inner Class一样，可以访问Outer Class的private字段和方法。之所以我们要定义匿名类，是因为在这里我们通常不关心类名，比直接定义Inner Class可以少写很多代码。
观察Java编译器编译后的.class文件可以发现，Outer类被编译为Outer.class，而匿名类被编译为Outer$1.class。如果有多个匿名类，Java编译器会将每个匿名类依次命名为Outer$1、Outer$2、Outer$3……
除了接口外，匿名类也完全可以继承自普通类。观察以下代码：
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
HashMap<String, String> map1 = new HashMap<>();
HashMap<String, String> map2 = new HashMap<>() {}; // 匿名类!
HashMap<String, String> map3 = new HashMap<>() {
{
put("A", "1");
put("B", "2");
}
};
System.out.println(map3.get("A"));
}
}
map1是一个普通的HashMap实例，但map2是一个匿名类实例，只是该匿名类继承自HashMap。map3也是一个继承自HashMap的匿名类实例，并且添加了static代码块来初始化数据。观察编译输出可发现Main$1.class和Main$2.class两个匿名类文件。
3、Static Nested Class
最后一种内部类和Inner Class类似，但是使用static修饰，称为静态内部类（Static Nested Class）：
public class Main {
public static void main(String[] args) {
Outer.StaticNested sn = new Outer.StaticNested();
sn.hello();
}
}
class Outer {
private static String NAME = "OUTER";
private String name;
Outer(String name) {
this.name = name;
}
static class StaticNested {
void hello() {
System.out.println("Hello, " + Outer.NAME);
}
}
}
用static修饰的内部类和Inner Class有很大的不同，它不再依附于Outer的实例，而是一个完全独立的类，因此无法引用Outer.this，但它可以访问Outer的private静态字段和静态方法。如果把StaticNested移到Outer之外，就失去了访问private的权限。
十二、classpath和jar
返回顶部目录 JVM通过环境变量classpath决定搜索class的路径和顺序；不推荐设置系统环境变量classpath，始终建议通过-cp命令传入；
jar包相当于目录，可以包含很多.class文件，方便下载和使用；
MANIFEST.MF文件可以提供jar包的信息，如Main-Class，这样可以直接运行jar包
十三、模块
返回顶部目录 Java 9引入的模块目的是为了管理依赖；使用模块可以按需打包JRE；
使用模块对类的访问权限有了进一步限制。
参考
廖雪峰Java
