周报2＞＞＞

面向对象的特征之继承：

1.使用extends建立子类与父类的继承关系

2.子类继承父类相当于子类把父类的功能复制了一份，但是，构造方法不能被继承。

3.继承后，子类可以使用父类的所有非私有资源，私有资源不可用的原因是不可见。

4.Java只支持单继承，一个子类只能有一个父类，但一个父类可以有多个子类。

5.继承具有传递性，爷爷的功能会传给爸爸，爸爸的功能会传给孙子。

6.继承是强耦合，关联性非常强的 is a 的关系。

关键字Super:

1.Super可以在父类成员变量与子类成员变量同名时，用Super.变量名的方式调用父类的成员变量。

2.还可以通过Super调用父类的构造方法，子类的构造方法首行默认存在Super();表示调用父类的无参构造，如果没有父类的无参构造，需要手动提供父类的其他含参构造供子类调用。

3.子类其实并不关心调用的是父类的哪个构造方法，只是需要先调用一个父类的构造方法而已，所以每次创建字类对象时，都会先调用父类的构造方法，再调用字类的构造方法。

注意：构造方法的调用只能在构造方法的首行

方法的重写：

前提：子类继承父类以后，对父类的功能进行改进

语法规则：两同 两小 一大

两同：子类的方法与父类的方法名+参数列表相同

两小：子类方法的返回值类型<=父类方法的返回值类型

          子类方法抛出的异常类型<=父类方法抛出的异常类型

一大：子类方法的修饰符>=父类方法的修饰符

注意：我们刚刚在重写规则中提到的方法的返回值类型的大小，指的不是值的大小，也不是字节的大小，我们这里指的大小是说：子类方法的返回值类型必须是父类方法返回值类型的字类或者是统一类型。

关键字static

1.静态可以修饰变量，方法，代码块

2.被static修饰的资源称作静态资源。

3.静态资源属于类资源，随着类的加载而加载，只加载一次。

4.静态资源可以被类名直接调用，原因是静态资源优先于对象加载，没有对象也可以使用。

5.静态资源被全局对象共享，只有一份

6.静态只能调用静态

7.静态代码块  static{ }

位置：类里方法外

执行时机：类加载时就加载，而且只会加载一次

作用：初始化，用于那些需要第一时间就加载，而且只加载一次的资源。

8.代码块的执行顺序

静态代码块，构造代码块，构造方法，局部代码块

关键字final：

final表示最终，可以修饰类，方法，属性

1.被final修饰的是最终类，不可以被继承

2.被final修饰的是方法的最终实现，不可以被重写

3.被final修饰的变量其实是常量，值不可以被修改，而且常量定义时必须同时赋值。

面向对象之多态：

1.前提：继承+重写

2..口诀1：父类引用指向子类对象

解释：父类类型的引用类型变量保存的是子类类型的对象的地址值

口诀2：编译看左边，运行看右边

解释：编译时要看父类是否定义了这个资源，运行时使用的是子类的功能。

3.资源使用情况

1）成员变量使用的是父类的

2）成员方法使用的是父类的方法定义，子类的方法体

3）如果多态对象调用的是子类没有重写过得方法，方法定义与方法体使用的都是父类的，所以这个不符合多态的前提，直接使用纯纯的父类对象调用即可。

4）静态资源属于类资源，随着类的加载而加载，只会加载一次，优先于对象进行加载，可以通过类名直接调用，被全局所有对象共享，所以静态不存在重写的现象，在哪个类定义，就属于哪个类的资源。

异常：

1.异常的继承结构

异常结构中的根是Throwable

Error:目前我们编码解决不了的问题

Exception异常

编译异常：未运行代码就报错了，强制要求处理

运行时异常：运行代码才报错，可以通过编译，不强制要求处理

2.异常的解决方案

1）捕获处理 try-catch- 自己处理

2）向上抛出 Throws- 交给别人解决

3）不能直接把异常抛给main(),因为调用main()的是JVM，没人解决了

抽象类

1.抽象类是被abstract修饰的类

2.抽象类对其中的方法不做限制，全普/全抽/半普/半抽

3.抽象类不可以实例化--创建对象

4.如果一个子类继承了一个抽象父类，只有两种解决方案：

继续抽象/实现抽象父类的所有抽象方法，变成普通字类

抽象方法：

1.抽象方法是被abstract修饰的方法

2.抽象方法没有方法体，一分号结束

抽象方法与接口的区别

1.抽象类是一个特殊的类，使用class定义，特殊在这个类中可以定义没有方法体的方法（抽象方法）

2.接口可以理解成一个特殊的抽象类，特殊在接口中所有的方法都是抽象方法，但注意接口不是类，用interface定义。

3.抽象类中有构造方法，为了给子类创建对象时使用

4.接口中没有构造方法的，子类调用的是父类的构造方法。

5.接口可以多继承，但抽象类只能单继承

6.抽象类可以定义普通的成员变量，但接口只能定义静态常量

7.接口与抽象类均不可以实例化/创建对象

8.抽象是后天重构的结果，接口是先天设计的结果

Object 顶级父类

1.Object是所有类的超类，java中的所有类都直接或者间接的继承自Object

2.如果一个类没有明确指定父类，那么这个类会默认继承Object类

3.Object所处的包是java.lang.Object,这个包是Java的核心包，不需要导包，会自动导包

String：

1.底层结构是char[ ]

2.char[ ] value = {'a','b','c'}

String s = new String(value);

3.String s ="abc";有高效的效果，因为数据在堆中常量池

StringBuilder/StringBuffer

1.前提：String类型的数据使用+拼接效率比较低

2.StringBuilder sb = new StringBuilder();

   StringBuffer sb2 = new StringBuffer();

3.sb.append()拼接方法效率比较高

正则表达式

1.就是我们指定的规则：String regex = "[0-9]{17}[0-9X]"

2.拿用户输入的数据做比较：

input.metches(regex)-->如果匹配，返回true.

包装类

基本类型只能存值，提供丰富功能的是基本类型对应的包装类

1.Integer有一个高效的效果：Integer valueof()  -128-127

3.创建方式：Integer i1 = new Integer(4);

                     Integer i1 = Integer.valueof(4);

自动装箱与自动拆箱

自动装箱：

编译器会自动把基本类型int5，包装成包装类型Integer，然后交给Integer类型的引用类型变量i3来保存。底层发生的代码：Integer.valueof(5)

valueof()的方向：int--》Integer

自动拆箱：

编译器会自动把包装类型的i1拆掉“箱子”，变回基本类型的数据，然后交给基本类型int的变量i4来保存。底层发生的代码：i1.valueof();

intvalue()的方向：Integer--》int

浮点数据运算不精确解决方案

Bigdecimal（String）

1.注意构造函数的参数是String，不是double，传double还是会不精确

2.做除法运算时除不尽会报错，所以使用重载的方法divide（要除的数，保留位数，舍入方式）

单元测试方法

是Java测试的最小单位，使用灵活

语法要求：@Test+public+void+没有参数

注意：Junit是一个单元测试工具，使用前必须导包

内部类：

1.我们可以把内部类看做是外部类的一个特殊成员

2.内部类可以直接使用外部类的所有资源，包括私有资源

3.外部类想要使用内部类的资源，需要创建内部类的对象才能使用

成员内部类

位置：类里方法外

被private修饰：

被私有化的内部类在main（）中无法直接创建对象，可以在私有的内部类所处的外部类中，创建一个公共的方法供外界调用，这个方法就可以用来创建私有内部类的对象并且调用私有内部类的功能。

被static修饰

static：静态，优先于对象加载，静态可以通过类名直接调用，静态只能调用静态

静态内部类可以不创建外部类对象，直接通过外部类类名.的方式创建内部类对象

如果静态内部类中还有静态方法，那么我们可以不创建对象，直接通过链式加载的方式使用这个静态方法。

局部内部类

位置：方法里

直接通过外部类创建对象，调用局部内部类所处的这个方法时，并不会触发局部内部类的功能！所以如果想要使用局部内部类的功能，需要在局部内部类所处的方法中，创建局部内部类的对象并调用这个局部内部类的功能。

匿名内部类

匿名对象：没有名字的对象，只能使用一次，一次只能调用一个方法，如果想要调用多次，或者是多个方法，就需要创建普通对象，或者是多个匿名对象来完成。

匿名内部类通常与匿名对象结合在一起使用。