JAVA基础复习3

面向对象编程 OOP

本质：以类的方式组织代码，以对象组织（封装）数据

//static 方法是和类一起加载的
public static void a(){
//  b();//错误！！！！
}
//类实例化 之后才存在
public  void b(){

}

构造器
1必须和类名相同
2必须没有返回类型，也不能写void
3一旦定义了有参构造，无参构造就必须显式定义
//快捷键ALT+INSERT
作用 ：
1使用new关键字，本质是在调用构造器
2用来初始化值

this. 代表当前类的

char 默认值为u0000

封装

我们的设计要追求
高内聚，低耦合
高内聚就是类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部使用
封装：通常应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
属性私有，get/set

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
JAVA中类只有单继承，没有多继承
继承是类和类之间的一种关系，除此之外，类和类的关系还有依赖，组合，聚合等
子类和父类之间，从意义上讲应该具有“is a”的关系

Java作用域
public
protect
default
private

子类继承了父类，就会拥有父类的全部方法
在Java中，所有的类都默认直接或者间接继承Object类

super调用父类的构造器，必须要在子类构造器的第一行
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法

super VS this
1，代表的对象不同：
this：本身调用者这个对象 没有继承也可以使用
super：代表父类对象的应用 只能在继承条件才可以使用

构造方法
this（）；本类的构造
super（）；父类的构造

重写

重写都是方法的重写，和属性无关
父类的引用指向子类
静态方法：方法的调用只和左边，定义的数据类型有关
非静态：重写

重写：需要有继承关系，子类重写父类的方法；
1，方法名必须相同
2，参数列表必须相同
3.修饰符：范围可以扩大但不能缩小；
4.抛出的异常：范围可以被缩小但不可被扩大

为什么要重写：
1，父类的功能，子类不一定需要，或者不满足；

多态

多态是方法的多态，属性没有多态性；
多态存在的条件：
1，有继承关系
2，子类重写父类的方法
3，父类引用指向子类对象

一个对象的实际类型是确定的
new Student（）；
new Person（）；

可以指向的引用类型就不确定了：父类的引用指向子类
Student s1 = new Student（）；
Person s1 = new Student（）；

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
如果子类重写了父类的方法，就执行子类的方法

注意事项：
1，多态是方法的多态，属性没有多态
2.父类和子类，有联系
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象

instanceof

引用类型，判断一个对象是什么类型

类型转换

子类转换成父类，可能丢失自己本来的一些方法
1，父类引用指向子类对象
2:，把子类转换为父类，向上转型；
3，把父类转换为子类，向下转型；强制转换；
4，方便方法调用，减少重复的代码

Static

匿名代码块：赋初值

静态导入包
import static java.lang.Math.random;

抽象类

abstract
抽象类可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类

抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类
public abstract class Action(){
public abstract void doSomething();
//抽象方法，只有方法名字，没有方法的实现
}

1.不能new这个抽象类，只能靠子类去实现它；约束；
2.抽象类中可以写普通方法；
3.抽象方法必须在抽象类中；

接口

interface
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是。。。则你必须能。。。”的思想。
接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计 模式都只针对具备了抽象能力的语言，就是因为设计模式所研究的，实际上就是如何合理的去抽象

接口中的所有定义都是抽象的 public abstract
//属性都是常量 public static final（不会用到）

public interface User{
void add(String name);
void delete(String name);
}

public class UserImpl implements User{
}
//实现了接口的类，就需要重写接口中的方法

作用：
1.约束
2.定义一些方法，让不同的人实现
3.public abstract
4.public static final
5.接口不能被实例化，接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法

内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就成为内部类，而A类相对B类来说就是外部类了。
1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类

Outer.Inner inner = outer.new Inner();

内部类可以获得外部类的私有属性方法

一个Java类中可以有多个class类，但是只能有一个public class

4.没有名字初始化类，不用将实例保存到变量中
new Apple().eat();
new UserService(){
@Override
public void hello(){
}
}

异常机制

Exception
简单分类
检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单忽略

运行时异常：运行时异常可能是被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略

错误ERROR：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如：栈溢出，它们在编译也检查不到的

异常体系结构

java.lang.Throwable作为所有异常的超类

ERROR
Error类对象由Java虚拟机生成并抛出，大多错误与代码编写者所执行的操作无关

Exception
在Exception分支中有一个重要的子类RuntimeException（运行时异常）
ArrayIndexOutOfBounsException(数组下标越界)
NullPointerException（空指针异常）
ArithmeticException(算术异常)
MissingResourceException(丢失资源)
ClassNotFoundException(找不到类)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理

这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常发生

ERROR和Exception区别：ERROR通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些错误时，JVM一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能去处理这些异常。

try{//监控区域
}catch(ArrayIndexOutOfBounsException e){
}catch(Exception e){//多个异常时，范围大的写在下面
}finally{//无论程序出不出错都执行
}
finally 可以不要finally，假设IO，资源，关闭

自定义异常
用户自定义异常类，只需要继承Exception类即可

1，创建自定义异常类
2，在方法中通过throw关键字抛出异常对象
3，如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
4，在出现异常方法的调用者中捕获并处理异常