Java学习03——面向对象编程

• 面向过程思想： 适合简单问题，一步一步来。
• 面向对象思想： 分类思想，先分类在对每个类进行单独思考，适合处理复杂问题以及多人协作。

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

• 三大特性：

  • 封装
  • 继承
  • 多态

• 静态方法static： 直接调用

• 非静态方法： 将方法实例化 Student student = new Student()，new出来这个方法再用

• 静态方法不可以直接调用非静态方法

• 类是抽象的，对象是具体的实例，类实例化之后会返回一个自己的对象。实例化用new

package LearnJava.OOP;

public class InstantAClass {
    public static void main(String[] args) {
        //实例化对象
        Student harry = new Student();
        harry.age=12;
        harry.name="Harry Potter";
        Student ron = new Student();
        ron.name="Ronald Weasly";
        ron.age=13;
        System.out.println(harry.name+" is "+harry.age);
        harry.study();
        System.out.println(ron.name+" is "+ron.age);
        ron.study();
    }
}


package LearnJava.OOP;

public class Student {
    String name;
    int age;

    public void study(){
        System.out.println(this.name+" is studying");
    }
}



//out
Harry Potter is 12
Harry Potter is studying
Ronald Weasly is 13
Ronald Weasly is studying

Process finished with exit code 0

• 构造器：和类名相同，没有返回值
• 作用：new本质在调用构造方法，初始化对象的值
• 注意点：定义有参构造后，如果想使用无参构造就在定义一个无参构造，alt+insert可以快速构造有参无参构造器

• 程序设计要求：高内聚，低耦合
• 属性私有(用private），提供一些方法操作——get/set，也可以使用alt+insert快速设置

• 对一批类再次抽象，形成如父子一般的关系。子类是父类的拓展是用extends
• 一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

package LearnJava.OOP.demo02;

public class ClassExtends {
    public static void main(String[] args) {
        Student student = new Student();
        student.speak();
        System.out.println(student.money);
        System.out.println(student.getAllMoney());
    }
}

//Peron为父类,但所有的类都会自动继承java的object类
public class Person {

    public int money = 10000;
    //private的是无法被继承的，只能通过get、set接口
    private int allMoney = 10000000;

    public int getAllMoney() {
        return allMoney;
    }

    public void speak(){
        System.out.println("I am speaking!");
    }
}

//学生为子类,子类继承父类就会拥有父类的全部方法
public class Student extends Person {

}


//out
I am speaking!
10000
10000000

• super

  • super调用父类的构造方法必须在构造方法的的第一个
  • super必须只能出现在子类的方法或构造方法中
  • super和this不能同时调用构造方法
  • this（）调用本类构造方法，super（）调用父类构造方法

• 方法重写 ：非静态的方法可以被重写。快捷键：alt+insert 的override

• 重写vs重载

  • 重写：方法名必须相同、参数列表必须相同、修饰符范围可以扩大但不可缩小
  • 重载：方法名必须相同、参数列表必须不同

• 为什么要重写？ 父类方法太多子类并不都需要，或者父类功能不满足子类需求

package LearnJava.OOP.demo03;

public class ClassOverride {
    public static void main(String[] args) {
        Son son = new Son();
        Father father = new Son();
        //test1为静态方法，调用时只和等号左边有关
        son.test1();
        father.test1();
        //test2为非静态方法，此时是子类重写了父类的方法，只有非静态方法是可以重写的
        son.test2();
        father.test2();

    }
}

public class Father {
    public static void test1(){
        System.out.println("i am father!");
    }
    public void test2(){
        System.out.println("i am father!");
    }

}

public class Son extends Father {

    public static void test1(){
        System.out.println("i am son!");
    }

    @Override//重写
    public void test2() {
        System.out.println("i am son!");
    }
}

//out
i am son!
i am father!
i am son!
i am son!

Process finished with exit code 0

• 多态是方法的多态

• 要有父子类之间的关系，且方法要重写

• 一个对象的实际类型是确定的，如new Student

• 可以指向的引用类型是不确定的：可以父类引用指向子类，但不能执行子类独有的方法。

• 对象能执行哪些方法主要看左边的类型，和右边的关系不大。而执行哪个方法看左边。

• instanceof关键字: X instanceof Y ，若X和Y之间有父子关系则编译通过，否则编译报错，而编译通过后若X的引用对象是Y引用对象的子类则为true否则false

• 类型之间转化，高转低强转加括号，低转高直接转就行

• static属于类，非static属于对象
• static代码块最先加载，匿名代码块其次，构造方法最后
• 还可以静态导入包
• 被final修饰的类是无法被继承的

• 不能new出来，只能用子类实现。
• 抽象类里可以写普通方法，而抽象方法必须写在抽象类里
• 抽象类更多起提示作用

• 作用：约束，定义一些接口让人实现
• 接口不能被实例化，接口中没有构造方法

package LearnJava.OOP.demo04;

//接口必须用类来执行，这个类必须重写接口中的方法，接口可以多继承。
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

//接口中只定义方法，并不写方法体
public interface UserService {
    public void add(String name);
    public void delete(String name);
    public void update(String name);
    public void query(String name);
}

public interface TimeService {
    public void timer();
}

• 指程序运行中出现的各种不期而至的状况

• 分类：

  • 检查型异常
  • 运行时异常
  • 错误ERROR：错误不是异常

• java把异常当做对象来处理，java的api中定义了许多异常类

• ERROR类对象有jvm生成并抛出，程序无法处理jvm会终止线程

• Exception分支中有一个重要的子类RuntimeException（运行时异常），通常异常可以被程序处理，在编程时要尽量避免异常，并在出现异常时及时处理

• 五个关键字：trycatchfinallythrowthrows

• 异常捕获——try/catch，快捷键ctrl+alt+t

package LearnJava.OOP.demo05;

public class DealWithException {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try{ //try监控区域
            System.out.println(a / b);
        }catch (ArithmeticException e){ //catch捕获异常
            System.out.println("程序出现异常，b不能为0");
        }finally { //善后工作
            System.out.println("finally");
        }

    }
}

//out
程序出现异常，b不能为0
finally

Process finished with exit code 0

• 抛出异常：throw在方法里捕获，throws在方法上捕获