Java面向对象

1、初识面向对象

面向过程思想：

步骤清晰简单，第一步做什么，第二步做什么。。。

面对过程适合处理一些较为简单的问题

面向对象思想：

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。

面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

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

1.1什么是面向对象

面向对象编程（Object-Oriented Programming，OOP）

面向对象编程的本质：以类的方式组织代码，以对象的方式封装数据。

从认识论角度考虑是先有对象后有类。对象是具体的事物；类是抽象的，是对 对象的抽象。

从代码运行角度考虑是先有类后有对象，类是对象的模版。

1.2类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一具体的事物。一个类中只能存在属性和方法。

对象是抽象概念的具体实例。

2、方法回顾和加深

方法的定义：

• 修饰符

• 返回类型

• break：跳出switch，结束循环 和 return 的区别

• 方法名：注意命名规范，见名知意

• 参数列表：（参数类型 参数名）

• 异常抛出：疑问

方法的调用：

• 静态方法

• 非静态方法

• 形参和实参

• 值传递和引用传递

• this关键字

静态方法只能调用静态方法，非静态方法可以调用静态方法。

遵循一个原则：被static修饰的内容会跟随类的加载而加载，所以静态化的内容可以不用实例化就直接调用，同时两个静态方法之间也可以互相调用。

值传递就是真实值在传递的时候传递的是他的副本 而不是其本身 所以在方法内改变其值并不会真正改变。

引用传递是指在调用函数时将实际参数的地址传递到函数中，在函数中对参数所进行的修改，将影响到实际参数。

3、对象的创建分析

3.1创建与初始化对象

使用new关键字创建对象

使用new关键字创建的时候，出了分配内存空间之外，还会给创建好的对象进行默认的初始化 以及对类中的构造器调用。

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

• 必须和类的名字相同

• 必须没有返回类型，也不能写void

一个类中即使什么都不写，它也存在一个方法（无参构造）。

在类中一旦定义了有参构造方法，无参构造方法就必须显示定义。

Alt+insert：生成构造器方法

4、面向对象三大特性

1.封装

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

封装就是隐藏对象的属性和实现细节，仅提供公共访问方式来让外界访问。把属性私有化（使用private）仅供自己使用，提供getter/setter方法供外部调用操作属性。

public class Encapsulation {

    private int age;
    private String name;
    private Double score;

    public void Judge(){
        if(score>=60){
            System.out.println(name+",你及格了");
        }else {
            System.out.println(name+",你不及格");
        }
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public Double getScore() {
        return score;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setScore(Double score) {
        this.score = score;
    }
}

测试：

public class Application {
    public static void main(String[] args) {
        Encapsulation enc = new Encapsulation();
        //enc.score//封装后不能通过 对象名.属性名的方法直接调用
        enc.setScore(50.0);//调用setter方法赋值
        enc.setName("王同学");
        System.out.println(enc.getScore());//通过getter方法取值
        enc.Judge();

    }
}

封装的意义/好处：

1.1 提高程序的安全性，保护数据。

1.2 隐藏代码的实现细节

1.3 统一接口

1.4 增加了系统可维护性

2.继承

继承的本质就是对某一批类的抽象，从而实现对现实世界更好的建模。

继承就是子类继承父类的属性和方法，还可以添加自己的属性和方法。在父类的基础上进行功能扩展，创建新的类型。

子类（派生类）继承父类（基类），使用extends关键字实现继承。

public class Father {
    private String name;
    public BigDecimal money=new BigDecimal(1_0000_0000);
    public String things;

    public void extendsProperty(){
        System.out.println("给你留下的"+money+"的财产和"+things);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

public class Son extends Father{
    private String name;
    private int age;

}

测试：

    public static void main(String[] args) {
        Son son = new Son();
        son.extendsProperty();
        BigDecimal sonMoney = new BigDecimal(20000);
        BigDecimal money = son.money.add(sonMoney);
        System.out.println("儿子现在总共有"+money);

    }

继承是类与类之间的一种关系。除此之外类和类之间的关系还有依赖，组合，聚合等。

JAVA中类只有单继承，没有多继承！ 一个儿子只有一个爸爸，一个爸爸可以有多个儿子。

父类中私有的属性和方法无法被继承。

在Java中所有的类都默认直接或者间接继承Object类，Object类是所有类的祖宗类。

Idea中 Ctrl+H 快捷键打开类的继承关系树。

父类：

public class Father {
    //如果用private修饰则 无法被继承。
    protected String name="超爸";
    public BigDecimal money=new BigDecimal(1_0000_0000);
    public String things;

    public void say(){
        System.out.println("给你留下的"+money+"的财产和"+things);
    }

    public Father() {
        System.out.println("父类无参构造");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public BigDecimal getMoney() {
        return money;
    }

    public String getThings() {
        return things;
    }

    public void setMoney(BigDecimal money) {
        this.money = money;
    }

    public void setThings(String things) {
        this.things = things;
    }
}

子类：

public class Son extends Father{
    private String name="小儿";
    private int age;

    public Son() {
        //隐藏代码：调用了父类的无参构造，super()
        super();//调用父类的无参构造必须要在子类构造器的第一行
        System.out.println("子类无参构造");
    }

    public void say(){
        System.out.print(name+age+"岁就拥有父亲");
        super.say();
    }

    public void test1(){
        say();//Son方法
        this.say();//Son方法
        super.say();//Father方法
    }

    public void test(){
        System.out.println(name);//小儿
        System.out.println(this.name);//小儿
        System.out.println(super.name);//超爸
    }
}

测试：

    public static void main(String[] args) {

        Son son = new Son();
        son.say();
        BigDecimal sonMoney = new BigDecimal(20000);
        BigDecimal money = son.money.add(sonMoney);
        System.out.println("儿子现在总共有"+money);
        son.setThings("一栋房子");
        son.test();
        son.test1();
        son.say();

    }

• this关键字：表示调用本类，本身调用者这个对象。

• super关键字：表示调用父类，代表父类对象的引用。

  • super调用父类的构造方法，必须在子类构造方法的第一行！

  • super只能出现在子类的方法或者构造方法中！

  • super和this不能同时调用构造方法。

两者区别：

• 前提

  • this：没有继承关系也能使用

  • super：只能在继承条件下使用

• 构造方法

  • this()：本类的构造

  • super()：父类的构造

2.1方法重写

//重写都是方法的重写，与属性无关
public class B {

    public void test(){
        System.out.println("B类测试");
    }
}

public class A extends B{

    @Override //方法重写 注解：相当于有功能的注释
    public void test() {
        //super.test();默认调用父类的方法
        //自己写一个实现
        System.out.println("A类测试");
    }
}

public static void main(String[] args) {

        //静态方法的调用只和左边定义了的类型有关
        //非静态方法：方法重写
        A a = new A();
        a.test();
        //父类的引用指向了子类
        B b=new A();//子类重写了父类的方法
        b.test();

}

重写：需要有继承关系，子类重写父类的方法；方法签名相同，方法体不同。

• 1.方法名必须相同

• 2.参数列表必须相同

• 3.修饰符：子类范围只能扩大但不能缩小 public > protected > default > private

• 4.抛出的异常：子类范围只能缩小不能扩大 Exception>ClassNotFoundException

• 5.返回值：子类返回值类型必须和父类相同或者是其子类

为什么需要重写：

1.父类的功能，子类不一定需要 或者 不一定满足

2.*继承后的属性赋值

    public static void main(String[] args) {
        
        Son son = new Son();
        String things = son.things;
        things="一座别墅";//子类调用父类公开属性，直接用等号赋值
        System.out.println(things);
        System.out.println(son.things);//不能给实际对象的属性值赋值
        System.out.println("-------------------------------");
        Father father = new Father();
        String things1 = father.things;
        things1="wse";//父类调用公开属性，直接用等号赋值
        System.out.println("baba说：是"+things1);
        System.out.println(father.things);//不能给实际对象的属性值赋值
        System.out.println("-------------------------------");
        son.extendsProperty();
        System.out.println("-------------------------------");
        father.setThings("一座游乐场");//父类调用父类setter方法赋值
        System.out.println(father.things);//可以给父类属性值赋值
        System.out.println(son.things);//不能对子类调用的属性值赋值
        System.out.println(father.getThings());
        System.out.println("-------------------------------");
        father.extendsProperty();
        System.out.println("-------------------------------");
        son.setThings("一个庄园");//子类调用父类setter方法赋值
        System.out.println(father.things);//不能给父类属性值赋值
        System.out.println(son.things);//可以给实际对象的属性值赋值
        System.out.println(son.getThings());
        System.out.println("-------------------------------");
        son.extendsProperty();
    }

说明：

3.多态

多态：即同一方法可以根据发送对象的不同而采用多种不同的行为方式。可以实现动态编译。

一个对象的实际类型是确定的，但可以指向对象的引用 的类型有很多（比如父类）

public class Mother {

    public void run(){
        System.out.println("母亲类的方法");

    }
}

public class Daughter extends Mother{

    @Override
    public void run() {
        System.out.println("女儿类中的方法");
    }

    public void eat(){
        System.out.println("女儿吃");
    }
}

测试：

    public static void main(String[] args) {

        //一个对象的实际类型是确定的
//        new Daughter();
//        new Mother();

        //但是可以指向的引用类型就不确定了  父类的引用指向子类
        //Daughter 能调用的方法都是自己的或者继承父类的
        Daughter daughter = new Daughter();
        //Mother 父类型 可以指向子类，但不能调用子类独有的方法
        Mother daughter1 = new Daughter();
        Object daughter2 = new Daughter();

        daughter1.run();//子类重新了父类的方法，执行子类的方法
        daughter.run();
        daughter.eat();
        //daughter1.eat();//无法调用子类独有的方法
    }

注意事项：

1.多态是方法的多态，属性没有多态。

2.父类和子类之间，有联系，没有联系会造成类型转换异常（ClassCastException）。

3.存在条件：有继承关系，子类重写父类方法，父类引用指向子类对象。

以下无法被重写

3.1. static方法：属于类，不属于实例。

3.2. final修饰的方法

3.3. private方法

4.instanceof和类型转换

instanceof：判断两个类是否存在父子关系。

使用方法：X instanceof Y

public class Mother {

}

public class Daughter extends Mother{

}

public class Teacher extends Mother{

}

测试：

    public static void main(String[] args) {

        //Object > String
        //Object > Mother > Teacher
        //Object > Mother > Daughter
        Object obj = new Daughter();
        System.out.println(obj instanceof Daughter);//true
        System.out.println(obj instanceof Mother);//true
        System.out.println(obj instanceof Object);//true
        System.out.println(obj instanceof Teacher);//false
        System.out.println(obj instanceof String);//false
        System.out.println("------------------------------------------");
        Mother mother = new Daughter();
        System.out.println(mother instanceof Daughter);//true
        System.out.println(mother instanceof Mother);//true
        System.out.println(mother instanceof Object);//true
        System.out.println(mother instanceof Teacher);//false
//        System.out.println(mother instanceof String);//编译报错，两者无关系
        System.out.println("------------------------------------------");
        Daughter daughter = new Daughter();
        System.out.println(daughter instanceof Daughter);//true
        System.out.println(daughter instanceof Mother);//true
        System.out.println(daughter instanceof Object);//true
//        System.out.println(daughter instanceof Teacher);//编译报错，两者无关系
//        System.out.println(daughter instanceof String);//编译报错，两者无关系
    
    }
}

类型转换：

1.父类引用指向子类的对象

2.把子类转换为父类，向上转型；

3.把父类转换为子类，向下转型；强制转换

4.方便方法的调用，减少重复的代码！简洁

public static void main(String[] args) {

	//类型之间的转换： 父类   子类  高转低需要强制转，低转高直接自动转
	//高                低
	Mother dau=new Daughter();//子类转成父类，很可能丢失一些子类独有的方法

	//dau将这个对象转换为Daughter类型，我们就可以使用Daughter类型的方法了
	Daughter daughter = (Daughter) dau;
	daughter.eat();
}

5.static关键字详解

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

public class Person {
    //第2个执行，可以用来赋初始值，创建一个对象执行一次。
    {
        System.out.println("匿名代码块");
    }
    //第1个执行，只执行一次
    static {
        System.out.println("静态代码块");
    }
    //第3个执行，创建一个对象执行一次
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        new Person();
        System.out.println("_______________________");
        new Person();
        //静态导入包之后，可以直接调用
        System.out.println(random());
        System.out.println(PI);

    }

}

5、抽象类和接口

abstract抽象类，抽象方法，只有方法名，没有方法的实现。

继承了抽象类的子类必须实现它的所有方法。

//abstract 抽象类 单继承
public abstract class Action {

    //abstract 抽象方法 只有方法名，没有方法的实现
    public abstract void doSomething();
    //普通方法
    public void playBalls(){
        
    };

}

//子类必须实现他的所有抽象方法
public class An extends Action{
    @Override
    public void doSomething() {

    }
}

特点：

1.不能new这个抽象类，只能靠子类去实现他：约束。

2.抽象类中可以写普通方法

3.抽象方法必须写在抽象类中

//抽象类存在构造器吗？存在的意义是什么？

接口：关键字interface

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

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

//interface 接口的关键字 接口都需要实现类
public interface UserService {
    //常量 public static final
    int AGE=99;
    
    //接口中的所有定义其实都是抽象的 public abstract
    
    void add();
    void delete();
    void update();
    void query();
 
}

public interface TimeService {
    void timeSum();
}

//抽象类：extends
//通过implements 去实现接口
//实现了接口的类，就需要重写接口中的方法。
//一个类只可以单继承，但可以有多个实现。
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add() {

    }

    @Override
    public void delete() {

    }

    @Override
    public void update() {

    }

    @Override
    public void query() {

    }

    @Override
    public void timeSum() {

    }
}

6、内部类及OOP实战

内部类就是在一个类的内部再定义一个类。比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

1.成员内部类

2.静态内部类

3.局部内部类

4.匿名内部类

public class Outter {

    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public void method() {
        //局部内部类
        class InnerA{

        }
    }

    //成员内部类
    class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getId(){
            System.out.println("内部输出外部类的Id:"+id);
        }
    }
    //静态内部类
    public static class InnerB{

    }

}
//成员内部类
class A{
    public static void main(String[] args) {

    }
}

public class Application {

    public static void main(String[] args) {
        Outter outter = new Outter();
        //通过这个外部类来实例化内部类
        Outter.Inner inner = outter.new Inner();
        inner.getId();

        //匿名内部类  没有名字初始化类，不用将实例保存到变量中。
        new Apple().eat();

    }
}

class Apple{
    public void eat(){
        System.out.println(1);
    }
}

7、异常

异常是指程序运行中出现的不期而至的各种状况，如：文件找不到，网络连接失败，非法参数等。

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

异常分为两大类：错误Error 和 异常Exception

1.Error和Exception

Error：指的是Java虚拟机无法解决的严重问题，由Java虚拟机生成并抛出；大多数错误与代码编写者所执行的操作无关。

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

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

Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。

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

Exception有两个子类：IOException 和 RuntimeException.

Error和Exception的区别：

Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，JVM一般会选择终止线程；

Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

2.捕获和抛出异常

1.异常处理机制

抛出异常

捕获异常

异常处理五个关键字：try、catch、finally、throw、throws。

public class Application {

    public static void main(String[] args) {
        Outter outter = new Outter();
        //通过这个外部类来实例化内部类
        Outter.Inner inner = outter.new Inner();
        inner.getId();

        //匿名内部类  没有名字初始化类，不用将实例保存到变量中。
        new Apple().eat();

    }
}

class Apple{
    public void eat(){
        System.out.println(1);
    }
}

public class Test2 {
    public static void main(String[] args) {
        int x=1;
        int y=0;

        try {
            new Test2().cheng(x,y);
        } catch (ArithmeticException e) {
            throw new RuntimeException(e);
        }

        /*//Ctrl+Alt+t 快捷生成try catch
        try {
            if (y==0){//throw  throws
                throw new ArithmeticException();//主动抛出异常,一般在方法中使用
            }
            System.out.println(x/y);
        } catch (Exception e) {
            e.printStackTrace();//打印栈的错误信息
        } finally {
        }
        */
    }

    //假设这方法中处理不了这个异常。可以在方法上抛出异常
    public void cheng(int x,int y) throws ArithmeticException{
        if (y==0){//throw  throws
            throw new ArithmeticException();//主动抛出异常,一般在方法中使用
        }
    }
}

Ctrl + Alt + T : 为代码块快捷生成条件/循环/抛出异常。

3.自定义异常

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

在程序中使用自定义异常类，大体可以分为以下几个步骤：

1. 创建自定义异常类

2. 在方法中通过throw关键字抛出异常对象。

3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

4. 在出现异常方法的调用者中捕获并处理异常。

//自定义异常类
public class MyException extends Exception{

    //传递数字 >10
    private int detail;

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

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

public class MyTest {

    //可能会存在异常的方法
    static void test(int a) throws MyException {
        System.out.println("传递的参数为："+a);
        if(a>10){
            throw new MyException(a);//抛出异常
        }

        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            //throw new RuntimeException(e);
            System.out.println("MyException:"+e);
        }
    }
}

异常总结：

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

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

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

4. 尽量去处理异常，切忌只是简单的调用printStatckTrace()去打印输出

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

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