Java笔记ヾ(◍°∇°◍)ﾉﾞ面向对象(OOP)之章

一、面向过程与面向对象

面向对象有物以类聚，分类的思维模式。

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到围观操作，仍然需要面向过程的思路去处理

面向对象编程的本质就是 以类的方式组织代码，以对象的组织（封装）数据

三大特性 封装继承多态

二、方法的调用

知识点： java里面都是值传递

public class Function {
    //非静态方法
    public void a(){
        System.out.println("调用了方法a");
    }
    //        调用不了a
    public static void b(){
    //        a();

    }
    //        能调用a
    public void c(){
        a();

    }
    //原因:静态方法和类相关，更早加载，普通方法和对象相关，类实例化之后才存在
    public static void main(String[] args) {
        Function f = new Function();
        Person p = new Person();
        f.a();
        //引用传递:本质是值传递
        System.out.println(p.name);//null
        Function.change(p);
        System.out.println(p.name);//cty
    }
    public static void change(Person person){
        //person是一个对象：指向的 ---> Person person = new Person(); 这是一个具体的人，可以改变属性
        person.name = "cty";
    }
}
class Person{
    String name;
}

三、面向对象语法

1、构造器

也称为构造方法，是在创建对象的时候必须调用的。并且构造器有以下两个特点

1、必须和类的名字相同
2、必须没有返回类型，也不能写void

使用new关键字，本质是在调用构造器

alt+insert 自动生成构造器

有参构造：构造方法重载，写了有参构造，默认无参构造就没了

2、内存分析

3、封装

程序设计追求高内聚、低耦合高内聚就是类的内部数据操作细节自己完成，不允许外部干涉。低耦合就是仅暴露少量的方法给外部使用

package com.cty.oop;

public class encapsulation {
    //属性私有
    private String name;
    //提供一些可以操作这个属性的方法
    //alt + insert 可以
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }
}

package com.cty.oop;

public class Application {
    public static void main(String[] args) {
        encapsulation e = new encapsulation();
        e.setName("cty");
        System.out.println(e.getName());
    }
}

4、继承

java只有单继承，没有多继承，但接口可以多继承

在java中，所有的类都默认继承自object类

package com.cty.oop;

public class inheritance
{
}
class person{
    public String name;
    public void say(){
        System.out.println("说了一句话");
    }
}
class student extends person{

}

package com.cty.oop;

public class Application {
    public static void main(String[] args) {
        student s = new student();
        s.say();
    }
}

5、super

访问父类的内容，类比super

构造一个子类的时候，会调用父类的无参构造，并且在第一行（默认就有）

package com.cty.oop;

public class inheritance
{
}
class person{
    public String name;
    public void say(){
        System.out.println("说了一句话");
    }
}
class student extends person{
    public student(){
        super();
        System.out.println("cty同学");
//        super();会报错
    }
}

重写有参构造先把无参加上

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

6、重写

package com.cty.oop;

public class Application {
    public static void main(String[] args) {
        //静态方法:看左边
        //非静态方法：重写，都是b的结果
        //重写关键词只能是public
        //重写只针对方法
        //修饰符：范围可以扩大不能缩小 public > Protected > Default > private
        //抛出异常：范围可以缩小不能扩大
        //为什么要重写
        //父类的功能子类不一定需要
        A a = new A();
        a.test();

        B b = new A();
        b.test();
    }
}

package com.cty.oop;

public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}

package com.cty.oop;

public class A extends B{
    @Override // 注解：有功能的注释
    //重写
    public void test(){
        System.out.println("A=>test()");
    }
}

7、多态

动态编译 类型：可扩展性

package com.cty.oop;

public class Application {
    public static void main(String[] args) {
        //一个类的实际类型是确定的
        //new B();
        //new A();
        //可以指向的引用类型就不确定了:父类的引用指向子类
        A a = new A();
        //父类型可以指向子类，但是不能调用子类独有的方法
        B b = new A();
        Object c=  new A();
        a.a();
        //强转就可以了
        ((A) b).a();
    }
}
/*
* 多态是方法的多态，属性没有多态
* 多态存在条件：1 继承关系 2 方法需要重写 3 父类引用指向子类对象
* */

package com.cty.oop;

public class A extends B{
    @Override // 注解：有功能的注释
    //重写
    public void test(){
        System.out.println("A=>test()");
    }
    public void a(){

    }
}

8、instanceof和类型转换

需要两个对象有一定的传承联系

9、static

①代码块

package com.cty.oop;
//学生类
public class Student {
    //构造时先调用,只执行一次，用来赋初始值
    static {
        System.out.println("静态代码块");
    }
    //构造时后调用
    public Student(){
        System.out.println("构造方法");
    }
    //构造时中调用
    {
        System.out.println("匿名代码块");
    }
}

②静态导入包

package com.cty.oop;
//静态导入包，下面可以直接用，不用加math
import static java.lang.Math.random;
public class Application {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(random());
    }
}

10、抽象类

package com.cty.oop;
//抽象类 最大特点是不能new，只能靠子类去实现
public abstract class Abstract {
    //只有方法的约束，没有方法的实现
    public abstract void doSomething();
}

package com.cty.oop;
//抽象类的所有方法，继承了它的子类都必须实现，除非子类也是抽象类
public class A extends Abstract{
    @Override
    public void doSomething() {

    }
}

11、接口

只有规范，自己无法写方法，专业的约束，约束和实现分离：面向接口编程

package com.cty.oop.demo;
//抽象的思维
//interface 定义的关键字 接口都需要有实现类
public interface UserService {
    //常量 public static final
    int AGE = 10;
    //接口中的所有定义的方法都是抽象的
    void a();
}

package com.cty.oop.demo;

public interface TimeService {
    void b();
}

package com.cty.oop.demo;
//实现了接口的类，需要重写接口中的方法
//利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService{
    @Override
    public void a() {

    }

    @Override
    public void b() {

    }
}

12、内部类（了解，不推荐）

1️⃣成员内部类

2️⃣静态内部类

3️⃣局部内部类

4️⃣匿名内部类

四、异常

1、检查性异常

最具代表的检查性异常时用户错误或问题引起的异常，这是程序员无法预见的

2、运行时异常

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

3、错误ERROR

错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了

4、异常体系结构

java把异常当作对象去处理，并定义一个基类java.lang.Throwable作为所以异常的超类

在 java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

1️⃣Error

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

Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，JVM一般会选择线程终止

还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

2️⃣Exception

在Exception分支中有一个重要的子类RuntimeException（运行时异常），这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理

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

3️⃣Error和Exception的区别

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

5、异常处理的五个关键字

try catch finally throw throws

package com.cty.exception;

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //快捷键 ctrl + alt + t
        try {//监控区域
            new Test().a(0);
        }catch (Exception e){
            e.printStackTrace();//打印错误栈信息
        }catch (Throwable e){//捕获异常，如果要捕获多个异常：层层递进，最大的在下面
            System.out.println("程序出现异常");
        }
        finally {//善后工作,可以不要，可以用来关闭等
            System.out.println("finally");
        }
    }
    //假设这个方法中处理不了异常 ------ 方法上抛出异常
    public void a(int k) throws ArithmeticException {
        if(k == 0){
            throw new ArithmeticException();//主动抛出异常，一般在方法中使用
        }
        b();
    }
    public void b(){
        a(1);
    }
}

6、自定义异常

使用java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可

package com.cty.exception;

public class Myexception extends Exception {
    private int detail;

    public Myexception(int a) {
        this.detail = a;
    }

    //异常的打印信息
    @Override
    public String toString() {
        return "Myexception{" +
                "detail=" + detail +
                '}';
    }
}

package com.cty.exception;

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //快捷键 ctrl + alt + t
        try {//监控区域
            new Test().a(15);
        }catch (Exception e){
            System.out.println("MyException"+e);
        }catch (Throwable e){//捕获异常，如果要捕获多个异常：层层递进，最大的在下面
            System.out.println("程序出现异常");
        }
        finally {//善后工作,可以不要，可以用来关闭等
            System.out.println("finally");
        }
    }
    //假设这个方法中处理不了异常 ------ 方法上抛出异常
    public void a(int k) throws Myexception {
        if(k > 10){
            throw new Myexception(k);
        }
    }
}

7、实际应用中的经验总结

处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理

在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常

对于不确定的代码，也可以加上try-catch，处理潜在异常

尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出

具体如何处理异常，要根据不同的业务需求和异常类型去决定

尽量添加finally语句块去释放占用的资源