面向对象
1.方法的调用
- 使用static修饰的方法，和类 一起加载的
- 未使用static修饰的方法，类实例化之后才存在
- 因此不能在使用static修饰的方法内调用另一个未使用static修饰的方法
2.构造器
形式
- 和类名相同
- 没有返回值
作用
- 使用new关键字，本质是在调用构造器
- 用来初始化对象的值
注意点
- 有参构造：一旦定义了，无参构造必须显示定义
3.封装
属性私有，get/set方法
4.继承
-
子类继承了父类，就会拥有父类的所有方法和属性
-
public>protected[不同包、同一包、类]>default[同一包、类]>private
-
只有单继承，没有多继承
-
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
-
this注意点
this:本身调用这个对象；super:代表父类对象的引用
this:没有继承也可以使用；super只能在继承条件下才可以使用
this();本类的构造；super();父类的构造
重写：需要有继承关系，子类重写父类的方法
方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小public>protected>default>private
4.抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException---->Exception(大)
5.重写，子类的方法和父类必须要一致，方法体不同
6.为什么要重写：父类的功能子类不一定需要，或者不一定满足
5.静态方法和非静态方法区别很大！！！
非静态方法可以调用静态方法，静态方法不可以调用非静态方法。
静态方法：方法的调用只和左边定义的数据类型有关
public class B {
public static void test(){
System.out.println("B-->test()");
}
}
public class A extends B{
public static void test(){
System.out.println("A-->test()");
}
}
//测试类
public class Application {
public static void main(String[] args) {
A a = new A();
a.test();//A-->test()
//父类的引用指向了子类
B b = new A();
b.test();//B-->test()
}
}
非静态方法：重写
public class B {
public void test(){
System.out.println("B-->test()");
}
}
public class A extends B{
public void test(){
System.out.println("A-->test()");
}
}
//测试类
public class Application {
public static void main(String[] args) {
A a = new A();
a.test();//A-->test()
//子类重写了父类的方法就调用子类，没有重写就调用父类
B b = new A();
b.test();//A-->test()
}
}
6.多态
- 对象执行那些方法，主要看对象左边的类型，和右边关系不大
- 父类可以指向子类，但是不能调用子类独有的方法
- 子类可以调用自己的或者继承父类的
- 多态是方法的多态，属性没有多态
7.多态存在的条件
- 有继承关系
- 子类重写父类
- 父类引用指向子类对象
A instanceof B判断B是否是A的子类,是结果为true,否则为false
Static
- 加载一个类时，先执行静态代码块–>匿名代码块–>构造方法
- 静态代码块只执行一次，在第一次加载类时
8.抽象类
- 不能new这个抽象类，只能靠子类去实现它
- 抽象类中可以写普通方法
- 抽象方法必须在抽象类中
9.接口(interface)
- 不能被实例化，接口中没有构造方法
- 所有定义的方法都是抽象的，public,abstract；属性都是常量，public static final
- 接口中只有方法的定义，都需要有实现类，可以实现多继承
- 类可以实现接口，implements,实现了接口的类就需要重写接口中的方法
10.final
- final修饰的类不能被继承
- final修饰的方法不能被子类重写
- final修饰的变量(成员变量和局部变量)，是常量，只能赋值一次，且用final修饰成员变量时，需要在定义变量的同时赋予一个初值
11.内部类
成员内部类
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
public void getID(){
System.out.println(id);
}
}
}
//测试类
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();//这是内部类的方法
inner.getID();//10
}
}
静态内部类
静态内部类不能直接访问非静态的属性
局部内部类
public class Outer{
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
匿名内部类
public class Test{
public static void main(String[] args){
//没有名字初始化类，不用将实例保存到变量中
new Apple().eat();
UserService userService = new UserService(){
@Override
public void hello(){
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface userService{
void hello(){
}
}
12.异常处理机制
public static void main(String[] args){
int a=1;
int b=0;
//假设要捕获多个异常：从小到大
try{
//try监控区域
System.out.println(a/b);
}catch(Error e){
//catch(想要捕获的异常类型)捕获异常
System.out.println("Error");
}catch(Exception e){
System.out.println("Exception");
}catch(Throwable e){
System.out.println("Throwable");
}finally{
//处理善后工作，可以不要，常用于关闭IO，资源
System.out.println("finally");
}
}
13.自定义异常
//自定义异常类
public class MyException extends Exception{
//传递数字>10;
private int detail;
public MyException(int a){
this.detail=a;
}
//to String
@Override
public String toString(){
reeturn "MyException{"+detail+'}';
}
}
//测试类
public class Test{
//可能存在的异常
static void test(int a)throws MyException{
System.out.println("传递的参数为："+a);
if(a>10){
throws new MyException(a);//抛出
}
System.out.println("OK");
}
public static void main(String[] args){
try{
test(5);//传递的参数为：5 OK
//test(11);//传递的参数为：11 MyException=>MyException{11}
}catch(MyExcepton){
System.out.println("MyException=>"+e);
}
}
}