Java面向对象知识点小结

---

再小的帆也能够远航💪

---

---

---

1. 面向对象程序设计概述

面向对象程序设计（object-oriented programming OOP）是当今主流的程序设计范型。它取代了20世纪70年代的“结构化”或过程式编程技术。

1.1 什么是面向对象

面向对象程序设计方法是尽可能模拟人类的思维方式，使得软件的开发方法与过程尽可能接近人类认识世界、解决现实问题的方法和过程，也即使得描述问题的问题空间与问题的解决方案空间在结构上尽可能一致，把客观世界中的实体抽象为问题域中的对象。

---

1.2 面向对象与面向过程

面向对象与面向过程是两种截然不同的思维方式
面向过程 侧重于亲力亲为，在程序设计中将问题步骤化，然后一个一个逐个去解决。总结起来就是八个字自顶向下 逐步细化。
面向对象 则表现为“找人办事”，找一些可以解决问题的对象来处理问题，只要对象能够满足要求，就不必关心其功能到底是如何实现的。总结起来就是两个字偷懒。

举一个现实生活中洗衣服的例子：
面向过程相当于你亲自洗，按部就班地把衣服脱下来，放入盆中，加入洗衣液，使劲揉搓，然后漂洗，然后晾晒。以达到把衣服洗干净的目的。
面向对象则是“找人办事”，比如你可以找你的女盆友帮你洗，什么？你没有女朋友？那好吧，那就找一台洗衣机帮忙，你只需要把衣服脱下来扔进洗衣机，剩下的就交给它了。只要它能达到把衣服洗干净的目的，那你就不必关心洗衣机的具体实现原理，只要知道怎么用就可以了。
除此之外还有很多例子，比如你饿了要吃饭，面向过程就是你自己买菜做饭然后吃完洗碗。而面向对象就像是你直接找了个餐馆，一切交给厨师，你只负责吃就行了。毕竟不管是面向对象还是面向过程，你的主要目的就是吃饱饭而已。

1.3 面向对象三大特征

• 封装
  所谓封装就是一种信息隐藏的技术，就是把属性进行私有化，简单点来说就是把对象的行为和属性看做是一个密不可分的整体，或者就是指把不需要把外界知道的信息进行隐藏，使得代码模块化。比如刚刚提到的洗衣机，它就是一种封装，将洗衣功能的实现隐藏于机身内部，外界无需知道它的功能是如何实现的，只需要知道使用它就可以将衣服洗干净就行了。
• 继承
  继承是面向对象的重要特征，如果一个类想要扩展另一个类的功能，就可以使用继承来实现，子类继承父类，那么子类就有了父类的一些属性和行为。继承也是一种共性抽取，Dog类和Cat类都有例如“颜色”，“品种”，“体重”等属性，都有“进食”，“睡觉”，“嬉戏”等行为。这些共性的属性和行为就可以向上抽取，定义在Animal类当中，这样只要Dog类和Cat类继承了Animal类，就无需再各自定义这些共性的内容，转而通过继承的方式，获取共性内容。
• 多态
  所谓多态就是对一个实例的相同方法在不同的情况下有不同表现形式。多态机制使得不同内部结构的对象可以共享相同的外部接口。这意味着，虽然不同类的内部操作不同，但是可以通过一个公共类，他们可以通过相同的方法给与调用。例如上文中所说的Dog类继承了Animal类，那么就可以把Dog类的对象当作Animal来使用。多态还可以体现在方法的重载上（后文叙述）。

---

2. 类与对象

类（class）是对象的抽象描述，对象是类的具体化实例。

可以把类看作构造对象的蓝图或者模版，比如生产手机之前，需要画手机的图纸，图纸中标识了手机应该有的尺寸，颜色，材质等必要信息。然后根据设计图纸就可以生产出一部部手机。这里的手机图纸就相当于类，而生产出的一部部手机就可以看成对象，手机图纸是手机的抽象描述，而手机则是图纸的一个个实例。

---

3. 权限修饰符

四种权限修饰符： public -> protected -> [default] ->private
[default] 为缺省写法，即什么都不写。

修饰符	本类可用	本包可用	不同包子类可用	本项目可用
public	✅	✅	✅	✅
protected	✅	✅	✅	❌
[default]	✅	✅	❌	❌
private	✅	❌	❌	❌

---

4. static 关键字

static关键字 意思为静态的，因此由它修饰的变量，常量，方法被称为静态变量，静态常量和静态方法。

4.1 静态变量

如果将一个变量定义为static，那这个变量就是静态变量，它将只属于类，通过该类创建的所有对象都只共享这一个静态变量 这与普通的成员变量有所不同：
普通的成员变量，在创建对象时，每个对象都拥有属于自己的成员变量副本。
如下代码：

pulic class DemoClass{
	public static int ID = 10;
	public int id;
}

public class MainClass{
	public static void main(String[] args){
		var a = new DemoClass();
		var b = new DemoClass();
		a.id = 25;
		b.id = 26;
		System.out.println(a.id);  // 25
		System.out.println(b.id);  // 26
		System.out.println(DemoClass.ID); //10
		}
}

定义了类DemoClass，包含一个静态成员变量ID和一个普通成员变量id
普通成员变量为对象所有，通过创建对象来实例化，因此对象a和对象b的 id 值并不相同
静态成员变量为类所有，在类编译时产生，所以需要通过 类名称.静态变量名 来调用，如 DemoClass.ID

4.2 静态常量

final 修饰的变量一经赋值就不能再改变，因此具有常量的属性。
同时被 static 和 final 关键字修饰的变量可称之为 静态常量，静态变量使用的不多，但静态常量却很常见。例如在 Math 类中定义一个静态常量 PI：

public class Math{
	public static final double PI = 3.14159265358979;
}

这样在程序中就可以通过 Math.PI来使用它了。
如果将 static 关键字省略，PI 就成了 Math 类的一个实例字段，也就是说需要 Math 类的对象来访问 PI，并且每个对象都有属于自己的 PI 副本。

4.3 静态方法

静态方法是不在对象上执行的方法，它和静态变量一样，为类所有。
java.lang.Math类是一个数学类，提供了大量用于操作数学运算的静态方法，其中一个为 pow() 方法，调用这个方法 Math.pow(x, y) 可以用来计算 x的y次方的值，在计算过程中，该方法并不需要任何 Math 类的实例对象参与其中。
注意 静态方法不能访问类的普通成员变量！！
例如定义一个 Employee 类，其中包含一个静态成员变量，一个普通成员变量和一个静态方法。

 public class Employee{
 	public static int ID; //静态成员变量
    public int id;		  //普通成员变量

    public static void method(){。  // 静态方法
            System.out.println(id); // 错误！不可访问普通成员变量
            System.out.println(ID); // 正确！可以访问静态成员变量
    }
}

产生错误的原因是：

静态成员变量和静态方法是属于类所有，产生于类的加载编译时期。
而非静态的普通成员变量则是在创建对象的时候才会实际产生。
先有的类，再有的对象
因此时间上，静态先于非静态，静态方法看不见非静态的普通成员变量，所以无法访问。

在调用静态方法时，

• 可以通过 类名称.方法名() 的方式，
• 也可以通过 对象名.方法名() 的方式

这都属于合法方式，但是并不推荐使用后者。
静态方法与对象毫无关系，这种调用方式是不符合情理的，容易造成混淆。
事实上使用对象名调用静态方法时，其底层依然是将对象名换成类名称然后再调用。
所以极力推荐使用 类名称.方法名() 的调用方式

---

5. final 关键字

final关键字 意为 最终的，不可改变的，因此被其修饰的量都具有最终性。

5.1 修饰一个类

final关键字可以用来修饰一个类，凡是被 final 所修饰的类将无法被其他类继承，也就是不能有子类，所以俗称为“太监类”。
例如：

public final class Fu{
}

public class Zi extends Fu{ //报错，提示 Fu 类是一个 final，所以不能继承它
}

5.2 修饰一个成员变量

被final修饰的成员变量的值是不可改变的，所以必须赋初值，或者通过构造方法赋值。
注意：对于基本数据类型，不可改变意味着变量的值不可改变。而对于引用类型的变量来说，不可改变是指引用的的地址值不可改变。

5.3 修饰一个局部变量

被final修饰的局部变量的值是不可改变的，所以必须赋初值。
注意：对于基本数据类型，不可改变意味着变量的值不可改变。而对于引用类型的变量来说，不可改变是指引用的的地址值不可改变。

5.4 修饰一个方法

被final修饰的方法将是最终的方法，它将不能被覆盖重写，因此可以知道：final关键字和abstract关键字不能同时使用，因为互相矛盾。

---

6. 方法的重载

方法的重载也是多态的一种表现形式。

所谓方法的重载就是指：多个方法的方法名称相同，参数列表不同。这样就构成了方法的重载。
如：

public class Test{
	public static void main(String[] args){
		add(2, 3); //将调用第一个重载的add方法
		add(2, 3, 4); //将调用第二个重载的add方法
		add(2.0, 3); //将调用第三个重载的add方法
		add(2, 3.0); //将调用第四个重载的add方法
	}
	
	public static int add(int a, int b){
        return a + b;
    }
    
    public static int add(int a, int b, int c){
        return a + b + c;
    }
    
    public static double add(double a, int b){
        return a + b;
    }
    
    public static double add(int a, double b){
        return a + b;
    }
}

上述代码中提供了4个 add 方法，这四个方法，方法名称相同，参数列表不同，因此构成了重载。调用方法时，编译器会根据传递的参数来自动识别具体要调用的方法。
方法的重载只与方法名称和参数列表有关，与返回值类型无关。

---