Java总结（2）

一、什么是方法的重写；
　　如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。语法规则　　返回值类型、方法名、参数类型及个数都要与父类继承的方法相同，才叫方法的重写

方法重写是指：子类中定义一个方法，并且这个方法的名字、返回值类型、参数个数和类型与从父类继承的方法完全相同。

方法的重写必须满足以下要求（从方法的五要素来分析）：
（1）要有继承；
（2）方法名，参数列表要相同；
（3）访问修饰符不能比父类窄；
也就是说，父类的public方法在重写时，访问修饰符必须是public，因为public的范围最大，否则就不构成方法的重写，例如：对于父类protected的方法，在重写时可以用protected或public来修饰。
（4）抛出的异常不能比父类更宽泛；
（5）返回类型要比父类的小或相同。
只有满足以上五个要求才符合方法的重写

二、方法重写和方法重载的区别；
　　方法重载：就是在同一个类中，方法的名字相同，但参数个数、参数的类型或返回值类型不同！
　　方法重写：它是指子类和父类的关系，子类重写了父类的方法，但方法名、参数类型、参数个数必须相同！

一、继承
1.1  继承概述
     继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。
     继承的格式：
         * 格式：public class 子类名 extends 父类名{ }
         父类:基类、超类
         子类：派生类
     继承中子类的特点：
         * 子类可以有父类的内容
         * 子类还可以有自己特有的内容

1.2  继承的好处和弊端
     继承的好处：
         * 提高了代码的复用性（多个类相同的成员可以放到同一个类中)
         * 提高了代码的维护性（如果方法的代码需要修改，修改一处即可）
      继承的弊端：
         * 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着发生变化，削弱了子类的独立性

1.3  继承中变量的访问特点
      在子类方法中访问一个变量：
      子类局部范围找 =>  子类成员范围找 => 父类成员范围找 => 如果都没有就报错（不考虑父亲的父亲）

1.4  super关键字
     super关键字的用法和super关键字的用法相似
         * this: 代表本类对象的引用
         * super: 代表父类存储空间的标识（可以理解为父类对象引用）

1.5  继承中构造方法的访问特点
      子类中的所有的构造方法默认会访问父类中无参的构造方法
      * 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
      * 每一个子类构造方法的第一条语句默认都是：super（）
      如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
      * 通过使用super关键字去显示的调用父类的带参构造方法
      * 在父类中自己提供一个无参构造方法
      推荐：自己给出无参构造方法

1.6  继承中成员方法的访问特点
     通过子类对象访问一个方法：
     子类成员范围找 => 父类成员范围找 => 如果都没有就报错（不考虑父亲的父亲）

1.7 方法重写
    方法重写概述：子类中出现了和父类中一模一样的方法声明
    方法重写的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，
    又定义了子类特有的功能。
    重写注意事项：
    1.父类中被private关键字修饰的内容，无法被子类继承和重写
    2.子类的访问权限不能低于父类的访问权限
@Override
    是一个注解
    可以帮助我们检查重写方法的方法声明的正确性
二、封装
2.1 封装的概述

   封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都隐藏在内部的，外界是无法直接操作的。
2.2 封装原则

  将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供相应的getXxx()和setXxx()方法
2.3 封装的好处

   通过方法控制成员变量的操作，提高了代码的安全性；把代码用方法进行封装，提高了代码的复用性。

三、多态
*3.1多态
     同一个对象，在不同时刻表现出来的不同形态
  举例：猫
     我们可以说猫是猫: 猫 Cat = new 猫（）；
     我们也可以说是猫是动物： 动物 animal = new 猫（）；
     这里猫在不同的时刻表现出来了不同的形态，这就是多态

     多态的前提和体现：
          * 有继承/实现关系
          * 有方法重写
          * 有父类引用指向子类对象

*3.2 多态中成员访问特点

     成员变量：编译看左边，执行看左边
                                         }=>  成员方法有重写，成员变量没有
     成员方法：编译看左边，执行看右边

3.3 多态的好处和弊端
    多态的好处：提高了程序的扩展性
       具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
    多态的弊端：不能使用子类的特有功能

3.4 多态中的转型
    * 向上转型
        从子到父
        父类引用指向子类对象
    * 向下转型
        从父到子
        父类引用转为子类对象3

Java 面向对象
面向过程：注重程序的流程，数据结构与算法，参与者就是它本身
面向对象：注重的事物的属性与行为，参与者更多是一个指挥者

extends（继承）
​ 继承是单继承：一个类只能有一个直接父类，但一个父类可以有多个子类
Java 中没有多继承，但是有多重继承，所有类的顶级父类是 Object 类

继承关系中，类的初始化顺序#
父类的静态 static
子类的静态
父类的普通（属性与方法） 代码
父类的构造
子类的普通
子类的构造

overload（方法的重载）#
发生在同一个类中
方法名相同
参数列表不同（个数不同，参数数据类型不同，个数与数据类型都不相同）
与返回值类型无关，与访问修饰符无关

override（继承方法的覆盖 / 重写）#
​ 在继承关系中，子类对父类的方法的重新实现
方法名与父类相同
参数列表也相同
返回值类型也相同，或者可以隐式转换成父类的返回值类型

继承转型#
向上转型：把子类对象转换成父类对象（是安全的，但子类对象的自身属性会被隐藏）
向下转型：把父类对象转换成子类对象
不允许直接 new 父类赋值给子类的向下转型
可以向上转型，再向下转型

混合类型转型#
​ 只能骗过编译器，运行会发生转换异常

访问修饰符#
修饰符：控制别的类对本类的属性与方法的访问权限
面向对象的封装，就是通过访问修饰符来控制访问权限
修饰符 数据类型 属性名；
修饰符 返回值类型 方法名（参数列表）
修饰符 class 类名｛｝
修饰符 本类 同包下的类（子类与非子类） 不同包的子类 不同包的其他类
public T T T T
protected T T T F
default T T F F
private T F F F
public：公共权限
protected：受保护的
default / 不写：默认
private：私有的

instanceof（判断对象类型）#
对象名 instanceof 类名：用来判断对象是否是类的实例

Java 中的常用方法#
构造方法#
​ Object() {}
toString()：返回类的类路径 + @+hascode对应的16进制数
equals(Object obj)：对象（Object）的比较 equals与==相同
hascode() ： 返回内存地址的整数

字符串序列（String）#
​ 构造：String() String(String s) String(byte s[]) String(char s[])

构造字符串对象#
​ String s = "hello";

字面量值赋值#
String s = new String("hello");

常用方法#
方法 描述
boolean equals(Object anObject) 重写了Object equals 比较字符串内容
boolean equalsIgnoreCase(Object anObject) 忽略大小写比较字符串内容
int length() 获取字符串长度
char charAt(int index) index → 0-length()-1 获取字符串中 index 位置的字符
indexOf("要查找的字符串") 返回第一次出现要查找的字符串的位置，如果查找不到返回-1
indexOf("要查找的字符串",int index) 跳过 index 位置，开始查找第一次出现要查找的字符串的位置
lastIndexOf("要查找的字符串") 返回最后一次出现要查找的字符串的位置
lastIndexOf("要查找的字符串"，int index) 跳过 index 位置，返回最后一次出现要查找的字符串的位置
substring(int begin) 截取字符串从 begin 开始到末尾
substring(int begin,int end) 截取字串，从 begin 开始到 end 不包含 end
replaceAll("原串"，"新串") 把字符串中的所有原字符串替换成新串
split("分隔符") 分割符把字符串分割成若干个字符，返回分割后的字符串数组
concat("xxx") 相对于 "原串" + "xxxxx"，字符串追加
Object 类#
​ Object 是 Java 的祖先类，基类，金字塔最顶端的类，最小的细胞类

如果是基本类型（byte short int long char float double boolean）
== 比较的内容（值）

如果比较是引用类型（类 接口 数组）

== 比较的是内存地址

equals 只能用于引用类型的比较

比较的时候看当前对象的类里面有没有重写 equals 方法，如果没有重写 equals 方法，默认调用 Object 里面的 equal 方法

如果重写 equals 方法，那么按照当前类中 equals 方法的逻辑进行比较

如果两个对象 equals() 返回true，那么 hashCode() 值会相同，但是两个对象 hashCode() 相同，两个对象未必能 equals() 相等

Java 重写#
继承关系中，子类对父类的方法重写实现
方法名相同
参数列表也相同
返回值类型也相同或者可以隐式转换成父类的返回值类型
访问修饰符的权限不能低于父类
 final 关键字#
​ final 修饰变量：就变成常量，不可以变

​ final 修饰方法：就变成最终方法，不可以被重写 override

​ final 修饰类：类就不可以被继承 （太监类）

StringBuffer 可变的字符串序列#
​ append() ：往字符串追加内容

​ insert(位置,"内容") ：往字符串指定位置追加内容

​ delete(int start,int end)：删除字符串从 start 开始到 end - 1 位置上的字符串

​ reverse() ：让里面的内容反转

System#
​ System.in：输入流

​ System.out ：输出流

获取控制台的输入对象#
Scanner in = new Scanner(System.in);
// 遇到空格就不往后取内容
in.next(); 
// 遇到换行符才不往后取内容
in.nextLine();
GC（garbage Collect） 垃圾回收器#
​ Java 程序垃圾是不需要程序员去手工回收，系统（JVM）在后台启动一个线程（守护线程） 每隔一定的时间，自动调用System.gc()方法，扫描系统中长时间

​ 未使用对象，或者对象指向null，自动回收这些对象。

​ 调用该对象的finalize()方法来释放占用的内容空间，当然程序员也可以手工调用System.gc()

 java.util.Date 时间类#
​ SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类

Date 时间格式
​ yyyy：四位年

​ MM：月

​ dd：日

​ hh：12进制时

​ HH：24进制时

​ mm：分

​ ss：秒

new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") 
new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss")
new SimpleDateFormat("yy年MM月dd日 HH时:mm分:ss秒 ") 
Math 数学工具类#
基本类型的包装类#
​ 基本类型的包装类里面都提供了操作该基本类型的属性与方法

基本类型 包装类
byte java.lang.Byte.
short java.lang.Short.
int java.lang.Integer.
long java.lang.Long.
float java.lang.Float.
double java.lang.Double.
char java.lang.Character.
boolean java.lang.Boolean.