面向对象
什么是面向对象
- 面向过程：根据解决问题的过程，直接设计系统。如 C 语言。
- 面向对象：将问题分解成多个对象，设计模块化、低耦合的系统。如 java 语言。
- 特性：封装、继承、多态。
- 优点：使系统更加灵活，易维护、易复用、易扩展。
封装
普通内部类
定义在类中的类，可以使用外部类所有属性和方法。普通内部类属于具体对象，因此不能声明 static 成员变量和方法。
成员内部类依附外部类而存在。也就是说，如果要创建普通内部类的对象，就必须首先存在外部类的对象。
public class Test { public static void main(String[] args) { // 创建内部类 Outter outter = new Outter(); Outter.Inner inner = outter.new Inner(); inner.output(); } } // 外部类 class Outter { private int num = "10"; // 内部类 class Inner { void output(){ System.out.println(num); } } }
局部内部类
定义在一个方法或者一个作用域里的内部类。对局部内部类的访问仅限于方法内或者该作用域内，且局部内部类不能被访问权限所修饰。
public class Test { public static void main(String[] args) { // 创建内部类 Factory f = new Factory(); Gun myrifle = f.getRifle(); } } class Factory { // 局部内部类 public Gun getRifle(){ class Rifle extends Gun { int len = 60; } return new Rifle(); } }
匿名内部类
匿名内部类不用定义名称，但必须继承一个父类或实现一个接口。由于没有类名，匿名内部类不能定义构造器。在创建匿名内部类的时候会立即创建它的实例。因此匿名内部类只能使用一次，通常用来简化代码编写。
最常用的情况就是在多线程的实现上，创建线程类传入参数需要继承 Thread 类或实现 Runnable 接口。
// 父类或接口 interface Person { public void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { // 定义匿名内部类并直接使用 public void eat() { System.out.println("eat apple"); } }; p.eat(); } }
JDK 1.8 中引入了 Lambda 表达式，你甚至连方法名都不需要写。
public class Demo { public static void main(String[] args) { Person p = new Person(() -> { System.out.println("eat apple"); }); p.eat(); } }
局部内部类和匿名内部类都定义在方法中，如果调用方法中的其他局部变量，只能调用外部类的局部 final 变量。因为在多线程中，外部类方法中定义的变量 A 在方法执行完毕后生命周期就结束了，而此时 Thread 对象的生命周期很可能还没有结束。内部类方法中访问的变量 A 实际上是拷贝。这就必须限定变量为 final，否则改动将导致数据不一致。
public class Test { public void test(final int b) { final int a = 10; new Thread(){ public void run() { System.out.println(a); System.out.println(b); }; }.start(); } }
静态内部类
静态内部类是不需要依赖于外部类，可以在不创建外部类对象的情况下创建内部类的对象。静态内部类不能使用外部类的非 static 成员变量或者方法。
public class Test { public static void main(String[] args) { // 无需外部对象，直接创建内部类 Outter.Inner inner = new Outter.Inner(); } } class Outter { static class Inner { int data = 0; } }
继承
类的继承
子类继承父类后，无需定义也可使用父类定义好的 public/protected 方法和属性。也可以进行扩展和方法的重写。
- 父类的属性值不会被子类继承，但子类可以通过父类提供的方法得到父类的属性值。
- 父类的 static 方法不会被子类继承，子类的 static 方法会隐藏父类的同名 static 方法。
- 父类的构造方法不会被子类继承，子类必须在构造方法首行调用父类构造方法（先构造父类，再构造子类）
final public class Trunk extends Car{ // 重定义属性（未公开无法继承） String brand; String description = "this is a trunk"; // 扩展属性 int goods; // 扩展方法 public void load(int num){ this.goods += num; } // 子类构造方法 public Trunk(String brand){ super(brand); this.goods = 0; } // 重写方法 @Override public void go(String loc){ super.go(loc); System.out.print(" with" + goods + "goods"); this.goods = 0; } }
Object 类是一切 java 类的父类。对于普通的 java 类,即便不声明也默认继承了 Object 类。
接口继承
和类的继承类似。但 Java 类只能单继承，而 Java 接口可以多继承。
interface Charge extends Move, Fight{ public abstract void kill(int num); }
多态
继承多态
- 重载(overload)：定义多种同名方法，调用时根据传入参数判定调用哪种方法。
- 重写(override)：子类定义完全相同的方法覆盖父类。
重写是多态的前提，其允许父类引用指向子类对象（引用类型为父类，指向的实际对象类型为子类）。
Car mycar = new Trunk("Benz");
但不允许子类引用指向父类对象。
Trunk mycar = new Car("Benz");
如果两个类之间存在继承关系，可以进行强制类型转换。强制类型转换只能改变引用类型，实际指向对象类型不会发生变化。
Trunk newCar = (Trunk)mycar;
方法多态
- 调用普通方法
子类同名方法会覆盖父类。执行方法根据实际对象类型来判定，即执行子类重写的方法。 - 调用 static / private / final 以及构造方法
- 特殊方法不能被覆盖，不存在多态。执行方法会根据引用类型来判定，即执行父类方法。
- 调用成员变量
父类属性值不会被子类继承，不存在多态。调用变量会根据引用类型来判定，即得到父类属性值。
Car myCar = new Trunk("Benz"); myCar.go("London"); // (trunk) go to London with 0 goods myCar.showNum(); // (car) 1 System.out.print(myCar.description); // (car) this is a car Trunk newCar = (Trunk)mycar; // 强制类型转换 System.out.print(newCar.description); // (trunk) this is a trunk
反射机制
JAVA 是动态编译语言（运行时才确定类型），支持反射机制。在运行状态中
- 对于任意一个类，都能够知道这个类的所有属性和方法；
- 对于任意一个对象，都能够调用它的任意一个方法和属性。
通过反射机制能更好地支持多态，降低模块耦合，提高代码灵活度（根据传入类名不同，就能实例化出不同的对象）。
但是在性能上会有较大的损耗。
尽管在应用层面很少使用反射机制，但在设计基础框架的时候反射机制非常有用。
反射机制运用
类的相关信息保存在以下类中，通过特定方法获取其对象能够知道这个类的信息。
- Class 类：类
- Constructor 类：类的构造方法
- Field 类：类的属性
- Method 类：类的方法
public class Reflection { public static void main(String[] args) { /************************** 获取 Class 对象 **************************/ // 第一种方式 返回对象的类 【已有对象，获取类无意义】 Student stu = new Student(); Class stuClass = stu.getClass(); // 第二种方式 获取数据类型的静态 class 属性 【需要导入类包】 Class stuClass = Student.class; // 第三种方式 返回路径下的类 【常用】 Class stuClass = Class.forName("Reflection.Student"); /************************** 获取 Class 信息 **************************/ // 获取类名 String name = stuClass.getName()); // 获取类的公有构造方法 Constructor[] conArray = stuClass.getConstructors(); // 获取类的全部构造方法 Constructor[] conArray = stuClass.getDeclaredConstructors(); // 获取类的指定构造方法（参数） Constructor con = stuClass.getConstructor(null); Constructor con = stuClass.getDeclaredConstructor(char.class); // 获取类的公有属性 Field[] fieldArray = stuClass.getFields(); // 获取类的全部属性 Field[] fieldArray = stuClass.getDeclaredFields(); // 获取类的指定属性（属性名） Field f = stuClass.getField("name"); // 获取类的公有方法 Method[] methodArray = stuClass.getMethods(); // 获取类的全部方法 Method[] methodArray = stuClass.getDeclaredMethods(); // 获取类的指定方法（方法名+形参类型） Method m = stuClass.getMethod("main", String.class); /************************** 在对象中使用 **************************/ Object obj = con.newInstance(); // 调用公有无参构造方法创建对象 f.set(obj, "X-man"); // 为对象的公有属性赋值 m.invoke(obj, "X-man"); // 调用对象的公有方法 }
泛型在编译时检查类型安全，编译过后泛型被擦除、实际类型才确定。反射是在编译期模拟 java 运行时的环境读取和调用程序，因此不能获得泛型的实际类型。但可以通过反射越过泛型检查：
在 String 泛型的集合中，你甚至可以添加一个 Integer 类型的值。
public class Demo { public static void main(String[] args) throws Exception{ ArrayList<String> strList = new ArrayList<>(); Class listClass = strList.getClass(); Method m = listClass.getMethod("add", Object.class); m.invoke(strList, 100); } }
