继承
概述： 多个类中存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过extends关键字让类与类之间产生继承关系。 class SubDemo extends Demo{}
继承的出现提高了代码的复用性；继承的出现让类与类之间产生了关系，提供了多态的前提。
特点：java只支持单继承，不支持多继承；支持多层继承。
注意：不要仅为了获取其他类中某个功能而去继承；类与类之间要有所属关系 is a xx1是xx2的一种
聚集：has a
聚合:班级里面有学生；球队中有球员
组合:心脏是人体的一部分，手人体的一部分（紧密联系程度不同）
子父类出现后，类中成员的特点
1、变量
如果子类中出现非私有的同名成员变量，子类要访问本类中的成员变量，用this；要访问父类中的成员变量，用super。
2、函数
3、构造函数
super关键字
this代表本类应用；super代表父类应用；当子父类出现同名成员时，可以用super进行区分；子类要调用父类构造函数时，可以使用super语句
函数覆盖（override）
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为复写或者重写；父类中的私有方法不可以被覆盖。在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。
覆盖：
1、覆盖时，子类方法权限一定要大于等于父类方法权限
2、静态只能覆盖静态
应用：
当子类需要父类的功能，而功能主体子类有自己特定内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
子类的实例化过程
子类中所有的构造函数默认都会访问父类中空参数的构造函数
因为每一个构造函数的第一行都有一条默认的语句 super()
子类会具备父类中的数据，所以要明确父类是如何对这些数据初始化的
当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。
class Fu { Fu() { System.out.println("Fu run..."); } } class Zi extends Fu { Zi() { //super() System.out.println("Zi run..."); } Zi(int x) { //super() System.out.println("Zi run..." + x); } } class ExtendsDemo { public static void main(String[] args) { Zi z = new Zi(); Zi z1 = new Zi(4); } } /* ---------- java ---------- Fu run... Zi run... Fu run... Zi run...4 输出完成 (耗时 0 秒) - 正常终止 */
？子类一定要访问父类中的构造函数
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问以下父类的构造函数，所以要访问父类的构造函数，可以通过定义super()语句访问。
final关键字
1、final可以修饰类、方法、变量。
2、final修饰的类不可以被继承。
3、final修饰的方法不可以被覆盖。
4、final修饰的变量是一个常量，只能被赋值一次。常量的书写规范：所有字母都大写，如果多个单词组成，单词间通过_连接
5、内部类只能访问被final修饰的局部变量。
修饰类 public final
抽象类
抽象：抽象就是从多个事物中将共性的、本质的内容抽取出来。
抽象类：java中可以定义没有方法体的方法。该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。抽象方法和抽象类都必须被abstract修饰
抽象类不可以被new创建对象，因为调用抽象方法没有意义。
抽象类中的抽象方法要像被使用 必须被子类覆写所有的抽象方法后，建立子类对象使用，如果子类只覆写了部分抽象方法，那么子类还是一个抽象类。
抽象方法：多个对象都具备相同的功能，但是功能具体内容有所不同。那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
疑惑点：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
/* 员工： 姓名 工号 工资 name id pay 经理：继承员工 + 奖金bonus */ abstract class Employee { private String name; private String id; private double pay; //员工初始化 Employee(String name, String id, double pay) { this.name = name; this.id = id; this.pay = pay; } //方法 public abstract void work(); } class Manager extends Employee { private int bonus; //经理初始化 Manager(String name, String id, double pay,int bonus) { super(name,id,pay); this.bonus = bonus; } public void work() { System.out.println("manager work..."); } } class Pro extends Employee { Pro(String name, String id, double pay) { super(name,id,pay); } public void work() { System.out.println("Pro work..."); } } public class AbstarctDemo { public static void main(String[] args) { Manager mg = new Manager("wu","1",1.1,1); mg.work(); } } /* ---------- java ---------- manager work... 输出完成 (耗时 0 秒) - 正常终止 */
模板方法设计模式：在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成
/* 需求: 获取一段程序运行的时间 原理: 获取程序开始和结束的时间并相减 获取时间 currentTimeMillis() */ abstract class GetTime { public final void getTime() { long start = System.currentTimeMillis(); runCode(); long end = System.currentTimeMillis(); System.out.println(" end-start:" + (end-start)); } public abstract void runCode(); } class SubTime extends GetTime { public void runCode() { for(int x=0; x<1000; x++) { System.out.print(x); } } } class TemplateDemo { public static void main(String[] args) { SubTime st = new SubTime(); st.getTime(); } } /* end-start:12 */
接口
接口 innterface{}
接口中的成员修饰符是固定的：
成员常量：public static final
成员函数：public abstarct
接口的出现将“多继承”通过另一种形式体现出来，即“多实现”implement。
特点
1、接口是对外暴露的规则
2、接口是程序的功能扩展。
3、接口可以用来多实现。
4、类与接口直接是实现关系，而且类可以继承一个类的同时实现多个接口。
5、接口与接口之间可以有继承关系。
多态
某一类事物的多种存在形态。
例如：猫这个对象对应的类类型是猫类型，也是动物的一种；父类型引用指向了子类对象。
体现：父类或者接口的引用指向或者接受自己的子类对象。
作用：多态的存在提高了程序的扩展性和后期可维护性。只能使用父类的引用访问父类的成员。
前提：需要存在继承或者实现关系。要有覆盖操作。
向上转型： Animal a = new Cat()
向下转型[强制将父类的引用转成子类类型]： Cat c = (Cat)a
多态的特点
成员函数：
编译时，要查看引用变量所属的类中是否有所调用的成员。
运行时，要查看对象所属的类中是否有所调用的成员
成员变量：只看引用变量所属的类。
静态成员函数特点：无论编译还是运行，都参考左边。
object类
方法
equals ：对对象是否相同的方法，可覆盖
class Demo //extends Object { } public class ObjectDemo { public static void main(String[] args) { Demo d1 = new Demo(); Demo d2 = new Demo(); Demo d3 = d1; System.out.println(d1.equals(d2)); System.out.println(d1.equals(d3)); System.out.println(d1==d2); System.out.println(d1==d3); } } /* ---------- java ---------- false //比较内存地址值 true false true */
//数值比较 class Demo //extends Obect { private int num; Demo(int num) { this.num = num; } //覆写父类方法 public boolean equals(Object obj) { //向下转型 Demo d = (Demo)obj; if(!(d instanceof Demo)) return false; return this.num == d.num; } } class Person { } class ObjectDemo { public static void main(String[] args) { Demo d1 = new Demo(4); Demo d2 = new Demo(5); Person p1 = new Person(); System.out.println(d1.equals(d2)); System.out.println(p1.equals(d1)); } } /* ---------- java ---------- false false */
toString 对象字符串表示形式
getClass().getName() + '@' + Integer.toHexString(hashCode())
内部类
定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）
特点：
1、内部类可以直接访问外部类中的成员，包括私有成员。
2、外部类要访问内部类中的成员必须要建立内部类的对象
class Outer { private int x = 3; //内部类可以直接访问外部类的成员，包括私有。 //外部类要访问内部类必须建立内部类对象 private class Inner 可以被私有，类中被访问 class Inner { int x = 4; void function() { int x = 6; /* ---------- java ---------- inner:6 inner:4 inner:3 */ System.out.println("inner:" + x); System.out.println("inner:" + this.x); System.out.println("inner:" + Outer.this.x); } } void method() { Inner in = new Inner(); in.function(); } } class InnerClassDemo { public static void main(String[] args) { Outer ot = new Outer(); ot.method(); //直接访问内部类成员 /* Outer.Inner in1 = new Outer().new Inner(); in1.function(); */ } }
位置：
成员位置：
1、可以被private static成员修饰符修饰
2、被static修饰的内部类只能访问外部类中的静态成员
Q1 在外部其他类中，如何直接访问static内部类的非静态成员？
new Outer.Inner().function();
Q2 在外部其他类中，如何直接访问static内部类的静态成员？
Outer.Inner.function()
注意：当内部类定义了静态成员，该内部类必须是static的
当外部类中的静态方法访问内部类时，内部类也必须是静态的。
class Outer { private static int x = 3; //内部类可以直接访问外部类的成员，包括私有。 //外部类要访问内部类必须建立内部类对象 private class Inner 可以被私有，类中被访问 //静态内部类 InnerClassDemo.java:12: 错误: 无法从静态上下文中引用非静态 变量 System.out.println("inner:" + x); static class Inner { void function() { System.out.println("inner:" + x); } } void method() { Inner in = new Inner(); in.function(); } } class InnerClassDemo { public static void main(String[] args) { Outer ot = new Outer(); ot.method(); } }
局部位置：
1、可以直接访问外部类中的成员
2、同时可以访问所在局部中的局部变量，但必须是被final修饰的
class Outer { int x = 3; void method(int x) { int y =4; class Inner { void function() { System.out.println("x = " + x); System.out.println("y = " + y); } } new Inner().function(); } } public class InnerClassDemo { public static void main(String[] args) { new Outer().method(4); } } /* ---------- java ---------- x = 3 y = 4 */
Q：定义内部类
当描述事物时，事物的内部还有事物，该事物用内部类描述。因为内部类事物在使用外部类事物的内容。例如：人体有器官等。
匿名内部类：就是内部类的简化写法
前提：内部类可以继承一个外部类或者实现接口
格式：new 外部类名或者接口名(){覆盖类或者接口欧中的代码/自定义内容}
Q1：建立一个戴内容的外部类或者接口的子类匿名内部类。
异常
Throwable
throws throw
异常处理
自定义异常
异常细节
包
classpath
包之间的访问
import
Jar包