Java面向对象编程详解

---

一、包

包(package) 是组织类的一种方式，使用包的主要目的是保证类的唯一性。
导入包中的类
Java中已经提供了很多现成的类供我们使用。

public class Test {
   
	public static void main(String[] args) {
   
	java.util.Date date = new java.util.Date();
	// 得到一个毫秒级别的时间戳
	System.out.println(date.getTime());
	}
}

上面的代码也可以写成这样：

import java.util.Date;
//import java.util.*;
public class Test {
   
	public static void main(String[] args) {
   
	Date date = new Date();
	// 得到一个毫秒级别的时间戳
	System.out.println(date.getTime());
	}
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*：其中*表示通配符，意味着导入这个包底下所有的类，但是Java在处理的时候，需要那个类，才会拿哪个类。而在C语言里面，通过include关键字导入之后，就会把这个头文件里面的内容全部都拿过来。

1.1静态导入

使用 import static 可以导入包中的静态的方法和字段。
例一：

import static java.lang.System.*;
	public class Test {
   
	public static void main(String[] args) {
   
	out.println("hello");
	}
}

例二：

import static java.lang.Math.*;
import static java.lang.System.*;
public class Test {
   
	public static void main(String[] args) {
   
	 out.println(max(10,20));
	}
}

通过静态导入的代码可读性不高，所以静态导入用的很少。

1.2将类放到包中

基本规则：

• 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
• 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如
• 包名要和代码路径相匹配. 例如创建 com.company.demo1的包, 那么会存在一个对应的路径 com/company/demo1 来存储代码.
• 如果一个类没有 package 语句, 则该类被放到一个默认包中.

1.3包的访问权限控制

我们已经了解了类中的 public 和 private. private 中的成员只能被类的内部使用.
如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用。
包的访问权限指的是只能在当前包当中进行使用，当你的成员变量不加任何访问修饰限定词的时候，它默认就是一个包访问权限。
同一个包下的成员变量可以访问，其他包下的成员变量无法从外部程序包中对其进行访问。

常见的系统包：

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
2. java.lang.reflect:java 反射编程包;
3. java.net:进行网络编程开发包。
4. java.sql:进行数据库开发的支持包。
5. java.util:是java提供的工具程序包。(集合类等) 非常重要。
6. java.io:I/O编程开发包。

二、继承

封装:不必要公开的数据成员和方法使用private关键字进行修饰。意义:安全性。
继承:对共性的抽取。使用extends关键字进行处理的。意义:可以对代码进行重复使用。
我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了。
基本语法：

class 子类 extends 父类 {
   

}

其中Cat这样的类, 我们称为子类, 派生类，Animal 这样被继承的类, 我们称为 父类 , 基类 或 超类。

class Animal {
   
	public String name;
	public Animal(String name) {
   
		this.name = name;
	}
	public void eat(String food) {
   
		System.out.println(this.name + "正在吃" + food);
	}
}
class Cat extends Animal {
   
	public Cat(String name) {
   
	// 使用 super 调用父类的构造方法.
	super(name);
	}
}
class Bird extends Animal {
   
	public Bird(String name) {
   
	super(name);
	}
public void fly() {
   
	System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
	}
}
public class Test {
   
	public static void main(String[] args) {
   
	Cat cat = new Cat();
	cat.name = "小黑";
	System.out.println(cat.name);
	cat.eat("猫粮");
	Bird bird = new Bird();
	bird.name = "圆圆";
	System.out.println(bird.name);
	bird.fly();
	}
}

[注意]：

• 使用 extends 继承父类.
• Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).即Java当中是单继承，不能同时继承两个类以上的类，包括两个。
• 子类会继承父类的所有 public 的字段和方法.
• 对于父类的 private 的字段和方法, 子类中是无法访问的.
• 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用。

2.1 super关键字

super：不能出现在静态方法中，其代表的是父类实例的引用。
super的两种常见用法：

1. 使用了 super 来调用父类的构造器。

public Cat(String name) {
   
	super(name);
}

2. 使用 super 来调用父类的普通方法.

public class Bird extends Animal {
   
	public Bird(String name) {
   
	super(name);
}
@Override
public void eat(String food) {
   
// 修改代码, 让子调用父类的接口.
	super.eat(food);
	System.out.println("我是一只小鸟");
	System.out.println(this.name + "正在吃" + food);
	}
}

在这个代码中, 如果在子类的 eat 方法中直接调用 eat (不加super), 那么此时就认为是调用子类自己的 eat (也就是递归了). 而加上 super 关键字, 才是调用父类的方法。即：如果子类和父类字段同名的话，则优先子类的字段，如果想要访问父类的字段，则要加上super关键字。

子类构造的同时，要先帮助父类来进行构造。需要在子类的构造方法当中，使用super关键字来显示的调用父类的构造方法。

super有3中表现形式：

1. super();//调用父类的构造方法
2. super.func();
3. super.data;

super与this的区别

super的概念：表示子类访问父类的属性、方法。不查找本类，而直接调用父类定义。
this的概念：访问本类中的属性、方法，其先查找本类，如果本类没有就调用父类。

2.2 protected 关键字

protected 关键字：对于类的调用者来说, protected 修饰的字段和方法是不能访问的，对于类的子类和同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的。

Java 中对于字段和方法共有四种访问权限

• private: 类内部能访问, 类外部不能访问。
• 默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
• protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.
• public : 类内部和类的调用者都能访问。

也就是说：
字段如果是public，在哪里使用都可以。
private只有在同一个包的同一个类中才能使用。
default在同一个包的同一个类及同一包中的不同类中可以使用。
protected在同一个包的同一个类中,同一包中的不同类中,及不同包中得子类中可以使用。

2.3 final 关键字

如果一个类不想被继承，我们可以设置为final修饰。
final 关键字修饰类, 此时表示被修饰的类就不能被继承。

1.final int a = 20；//常量，不可以被修改
2.final Class A{
    //代表整个类不可以被继承
}
3.final修饰方法

三、组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。
组合并没有涉及到特殊的语法(诸如extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段.这是我们设计类的一种常用方式之一。
如一个学校：

public class Student {
   
...
}
public class Teacher {
   
...
}
public class School {
   
	public Student[] students;
	public Teacher[] teachers;
}

组合表示 has - a 语义。
如：一个学校中 “包含” 若干学生和教师.
继承表示 is - a 语义。
在上面的 “动物和猫” 的例子中, 我们可以理解成一只猫也 “是” 一种动物。

四、多态

4.1向上转型

向上转型：表示往父类的方向转。

向上转型发生的时机:

1. 直接赋值

在上面的例子中有：

public class Test {
   
	public static void