面向对象、异常、API

面向对象

//面向过程和面向对象
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为
​
//匿名对象
new People().Method;//这是两个对象 只能调用一次
new People().Method;

1.封装

封装三要素

封装性：封装是面向对象的核心思想，对对象的属性和行为封装起来，不需要外界知道具体的实现细节，这就是封装。 * 封装三部曲

* 1、把属性私有化 private

* 2、给属性提供公共的getter 和 setter方法

* 3、给getter或setter方法里添加逻辑控制

2.继承

在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。

class 父类 {
}
 
class 子类 extends 父类 {
}
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

3.抽象和接口

1.抽象：abstract

Java中允许在定义类时不能实例化，定义方法时不写方法体，不包含方法体的方法称抽象方法，抽象方法必须使用abstract关键字修饰，当一个类包含了抽象方法，那么该类必须使用abstract关键字来修饰，使用abstract修饰的类称之为抽象类。 
    注意：抽象类不能被实例化，因为里面可能有抽象方法，所有抽象类只能被继承，然后让子类重写抽象方法，调用子类具体的方法。
    抽象总结：
1、类中有抽象方法，那么该类一定抽象类
2、抽象类可以没有抽象方法
3、抽象类被子类继承后，一定要重写，但是如果子类不重写那么可以把子类定义成抽象类
    //抽象类
public abstract class Animal {
​
    //抽象方法
    public abstract void eat();
}

2.接口（implements）

如果一个类中所有的方法全部都是抽象的，则可以使用另外一种表现方式来定义，就是接口！接口是由常量和抽象方法组成的特殊类，是对抽象类的进一步抽象。
总结接口：
1、接口中的方法都是抽象的，不能实例化对象
2、接口中的属性都是常量
3、当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法
4、一个类通过implements关键字来实现接口时，可以实现多个接口，被实现的多个接口之间要使用逗号隔开。

//接口：interface 类：class
public interface Animal {
//默认添加public static final String NAME = "zhangsan";
    String NAME = "zhangsan";
//抽象方法
    public abstract void eat();
    void sleep();
}
​
​
//接口使用implements实现,子类实现接口，必须实现接口中的所有方法,可以多实现接口
public class Dog implements Animal,Pet {
//重写父类
    public void eat() { 
    }
    public void sleep() {   
    }
    public void play() {    
    }
}

4.多态

多态的好处可以使程序有良好的扩展并可以对所有类的对象进行通用处理
1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性
   
多态存在的三个必要条件
继承
重写
父类引用指向子类对象：Parent p = new Child();
但是不能调用子类特有方法

public static void animalShout(Animal animal) {
    //向下转型  instanceof该对象是否是某个类型
    if (animal instanceof Cat) {
        Cat cat = (Cat) animal;
        cat.shout();
        cat.sleep();
    }else {
        System.out.println("该对象不是猫类型");
    }
}

异常

//错误类表示java运行时产生的系统内部错误或者资源耗尽的错误仅靠修改程序不能恢复执行
//异常类表示程序本身可以处理的错误。RuntimeException类及其子类表示运行时的异常，Exception其他子类均表示编译时的异常。

		Throwable
	Error		Exception
IOError	错误 类		异常类	其他	RuntimeException
AWTError					算数异常	ArithmeticException
其他子类						ClassCastException
						其他子类

String getMessage()  返回此throwable的详细消息字符串
void printStackTrace()   将此throwable及其追踪输出至标准错误流  
void PrintStackTrace(PrintStream s)  将此throwable及其追踪输出到指定的输出流

try{                         （可以没有finall代码块）
    //把可能出错的代码放进来   （发生异常后 try里异常后面的代码不执行）
} catch(Exception e) {
    //如果捕获到异常后，进入    
    用e打点调用异常获取方法
    return;
} finally{
    //不管是否遇到异常都进入
}
//return结束当前方法，只执行finally语句。
//如果在try...catch中执行了System.exit(0)就会退出当前虚拟机，任何代码不会执行。

注意：1、catch代码块对异常进行处理，如果代码处理完成后，程序则不停止，继续向后执行 2、不管发不发生异常都进入写入到finally代码块中 3、如果你在catch中return对后续代码有影响，但对finally代码块中的代码没有影响 4、不能没有try，可以省略catch或者finally 5、可以写多个catch块捕获不同的异常，但是顺序是从小到大！！

throws方法声明

throw抛出异常

API

指的时应用程序编程接口

String

创建字符串最简单的方式如下:
String str = "Runoob";
​
用构造函数创建字符串：
String str2=new String("Runoob");
​
String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：
String s1 = "Runoob";              // String 直接创建
String s2 = "Runoob";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建

String 方法

连接	concat（）	string1.concat(string2);
替换	replace（）	string1.replace（“1”，“2”）；
去除空格	trim（）	string1.trim（）；
转换	valueOf（）	string1.valueOf（）；
判断Boolean	开头startWith（）	包含字符串contains（）判断空isEmpty（）
截取	substring（）	string1.substring（索引，索引）
分割	split（）	string1.split（分割符）

StringBuffer

由于字符串是常量，一旦创建内容和长度不可改变。如果需要对一个字符串进行修改，则需要创建新的字符串。
为了便于修改，JDK提供了一个StringBuffer类（字符串缓冲区）。
  StringBuffer String 最大的区别在于可不可以改变。 类似一个容器，添加删除字符时，并不会产生新的SrigBufer（未使用）对象。
    
    结束系统
System.exit(0);
    垃圾回收
System.gc();

StringBuffer方法

添加
Append(char c);

包装类

基本数据类型      对应的包装类
byte                Byte    
char(charact)       Charact
int(integer)        Integer
short               Short
float               Float
double              Double
boolean             Boolean
​

14.集合Collection

//ctrl+shift+o快速导包
Collection(单列集合的根接口)
1.list接口:有序，可重复(Arraylist,LinkedList)实现类
2.Set接口：无序，不可重复(HashSet)实现类
Map(双列集合的根接口)
1.HashMap实现类

//使用迭代器遍历集合
Iterator<String> it = coll.iterator();
while (it.hasNext()) {
    String str = it.next();
//当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
    System.out.println(str.length());
}
//使用for迭代
for (Iterator it = coll.iterator(); it.hasNext(); ) {
    System.out.println(it.next());
}