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

Java学习03——面向对象编程 1、面向过程&面向对象

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

2、面向对象编程（OOP）

本质：以类的方式组织代码，以对象的组织（封装）数据。
三大特性：
- 封装
- 继承
- 多态

3、方法的调用

静态方法static：直接调用
非静态方法：将方法实例化 Student student = new Student()，new出来这个方法再用
静态方法不可以直接调用非静态方法

4、类和对象的关系

类是抽象的，对象是具体的实例，类实例化之后会返回一个自己的对象。实例化用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

5、构造器

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

6、封装

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

7、继承

对一批类再次抽象，形成如父子一般的关系。子类是父类的拓展是用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

8、多态

多态是方法的多态
要有父子类之间的关系，且方法要重写
一个对象的实际类型是确定的，如new Student
可以指向的引用类型是不确定的：可以父类引用指向子类，但不能执行子类独有的方法。
对象能执行哪些方法主要看左边的类型，和右边的关系不大。而执行哪个方法看左边。
instanceof关键字: X instanceof Y ，若X和Y之间有父子关系则编译通过，否则编译报错，而编译通过后若X的引用对象是Y引用对象的子类则为true否则false
类型之间转化，高转低强转加括号，低转高直接转就行

9、static关键字详解

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

10、抽象类abstract

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

11、接口

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

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();
}

12、异常Exception

指程序运行中出现的各种不期而至的状况
分类：
- 检查型异常
- 运行时异常
- 错误ERROR：错误不是异常
java把异常当做对象来处理，java的api中定义了许多异常类
ERROR类对象有jvm生成并抛出，程序无法处理jvm会终止线程
Exception分支中有一个重要的子类RuntimeException（运行时异常），通常异常可以被程序处理，在编程时要尽量避免异常，并在出现异常时及时处理

13、异常处理机制

五个关键字：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在方法上捕获

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

Java相关栏目本月热门文章