Java面向对象（OOP）

介绍

1. 面向对象编程（Object Oriented Programming，OOP）& 面向过程编程（Procedure Oriented Programming，POP）
   
   

---

方法的调用

1. 静态方法（main方法中：类名.方法名，即可调用此方法）
2. 非静态方法

通过 new 实例化这个类
对象类型  对象名 =  对象值
    
例：
有一个类Student，类里有个方法为say
故需要在main方法中输入：
    
    Student stu = new Student();
	stu.say();

---

类与对象的创建

//new 实例化了一个对象
Person01 person01 = new Person01("zzl");

System.out.println(person01.name);

构造器：
1.和类名相同
2.没有返回值

作用：
1.new本质在调用构造方法
2.初始化对象的值

有参与无参
public class Person01 {
    String name;

    //一个类即使什么也不写，它也存在一个方法

    //创建有参构造后，无参可以不写代码
    public Person01(){
        //this.name = "zzl";
    }

    //有参构造：一旦定义了有参构造，无参就必须显示定义
    //Alt + Insert，生成快捷键
    public Person01(String name) {
        this.name = name;
    }
}
    

---

封装

1. 即在一个类中使用get/set方法
   

---

继承

super:
	1.super调用父类的构造方法，必须放在构造方法的第一个
	2.super和 this不能同时调用构造方法，因为两者都需要在第一个
	# super(); || this();
	3.super只能出现在子类的方法或构造方法中
	4.只能在继承条件下才可以使用
	
this:
	1.代表本身调用者这个对象
	2.没有继承也可以使用
	3.在构造方法中代表本类的构造

重写：
	1.需要有继承关系，由子类重写父类
	2.方法名、参数列表必须相同，但方法体不同
	3.修饰符（范围可以扩大，但不能缩小）：Private < Default < Protected < Public
	4.抛出的异常（范围可以缩小，但不能扩大）：Exception > ClassNotFoundException 
	
(因为父类的功能，子类不一定需要或不一定满足，故有重写的需求)

#优先调用super()即父类
#object类的无参构造处于“栈”顶部，最后被调用，但最先执行结束
#后进先出原则

public class SuperTest02 {
    public static void main(String[] args) {
        //输出1 3 6 5 4 
        new C2();
    }
}

#此处的Object可省略，sum公司定义好的，默认继承
class A2 extends Object{
    public A2(){
        System.out.println("1");
    }
}

class B2 extends A2{
    public B2(){
        System.out.println("2");
    }

    public B2(String name){
        //默认有super(); 因此跳转到A2的无参构造，先输出1
        System.out.println("3");
    }
}

class C2 extends B2{
    public C2(){
        this("zzl");
        System.out.println("4");
    }

    public C2(String name){
        this(name, 18);
        System.out.println("5");
    }

    public C2(String name, int age){
        super(name);
        System.out.println("6");
    }
}

---

多态

多态：
	1.父类和子类有联系，可进行转换，而无联系的类型之间不可转换
	2.父类引用指向子类的对象
	3.把子类转换为父类，向上转型，可能会丢失子类的方法
	4.把父类转换为子类，向下转型，需使用强制转换
	5.类型转换异常：ClassCastException
	6.存在条件：继承关系，方法需要重写，父类引用指向子类对象
	7.但static方法属于类，不属于实例，final为常量，以及private此三类不能被重写

（最终目的就是为了方便方法的调用，减少重复的代码，简洁至上）

（抽象家族：封装、继承、多态；抽象类、接口）

---

abstract抽象类

1. 抽象类的所有方法，都要由继承了它的子类去实现，除非子类也是抽象类
2. abstract抽象类，既然是类即是单继承
3. 抽象方法必须在抽象类中
4. 抽象类存在的意义即将重复的内容抽象出来，由子类继承去修改实现需要的功能，提高开发效率
    
public abstract class Action {

    //抽象类不能有方法体，由子类继承后去填补功能的代码内容
    public abstract void hello();

    //抽象类中也可以写普通的方法
    public void say(){
        System.out.println("Hello World!");
    }
}

---

接口

#类可以实现接口 implements 接口
#实现了接口的类，就需要重写接口中的方法
#且可多继承，即变相地利用了接口的来实现伪多继承

---

内部类

1. 成员内部类

//外部类
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.getID();
    }
}

2. 局部内部类

public class Outer {
    
    //局部内部类即在方法内写一个类
    public void method(){
        class Inner{
            
        }
    }

}

3. 匿名内部类

public class Test {
    public static void main(String[] args) {
        //实例化Apple类
        //Apple apple = new Apple();
        
        //匿名内部类则不需要实例化
        //即直接调用
        new Apple().eat();
    }
}

class Apple{
    public void eat(){
        System.out.println("吃苹果~");
    }
}

---

Error&Exception

1. 什么是异常
   

2. 简单分类
   

3. 异常体系结构
   

4. Error
   

5. Exception
   

---

异常处理机制

//try, catch, finally的简单使用
public class Test {
    public static void main(String[] args) {

        int a = 8;
        int b = 0;


        //try监控区域
        //catch（需要捕获的异常类型 e，最高的为Throwable）捕获异常
        //catch(类型范围大的往下放，例如最大的Throwable放最后)
        //finally处理善后工作，可以不使用，一般用于IO流等关闭操作
        //选择输出语句，快捷键Ctrl+Alt+T，选择模板
        try{
            System.out.println(a/b);
        }catch(Error e){
            System.out.println("Error");
        }catch (ArithmeticException e){
            System.out.println("程序出现异常，分母不能为0");
        }catch (Throwable e){
            System.out.println("Throwable");
        }finally {
            System.out.println("finally");
        }
    }
}

//throw的简单使用
//一般在方法内使用
public class Test {
    public static void main(String[] args) {

        new Test().test(a:4, b:0);
        
    }
    
    //即不用sout输出语句，控制台也会输出异常信息
    public void test(int a, int b){
        if (b==0){
            //主动抛出异常
            throw new ArithmeticException();
        }
    }
}

//throws的简单使用
//throws即在方法上抛出异常
public class Test {
    public static void main(String[] args) {

        try {
            new Test().test(4,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
        
    }
    
    //假设在这方法中，无法处理此异常
    //此时使用throws，即在方法上抛出异常
    public void test(int a, int b) throws ArithmeticException{
        if (b==0){
            //主动抛出异常
            throw new ArithmeticException();
        }
    }
}

---

自定义异常

（无特殊情况，一般使用Java定义好的）

（经验小结）