面向对象的简单概括

面向对象(oop)

面向对象的本质：以类的方式组织代码，以对象的组织（封装）数据。
三大特性：封装，继承，多态。
类与对象的关系：类是对象的模板

类与对象的创建

类创建

public class Demo01 {
    String name;//类属性
    //类方法
    public void study(){
        System.out.println("OK!");
    }
}

对象的创建

public static void main(String[] args) {
        //类实例化后会返回自己的一个对象
        //demo01就是Demo01类的具体实例
        //创建demo01实例化Demo01类
        Demo01 demo01 = new Demo01();
    }

构造器

一个类即使为空，也会存在一个无参数构造方法

方法名和类名一致，没有返回值，public，没有参数
用来实例化初始值

public class Demo01 {
    //无参数构造方法
    public Demo01() {
    }
    String name;//类属性
    //类方法
    public void study(){
        System.out.println("OK!");
    }
}

new关键字本质为调用构造器
一旦定义了有参数构造方法，无参就必须显示定义
alt+insert生成构造器

创建对象内存分析

封装

特点：
- 高内聚，低耦合
- 属性私有（private）其他类无法调用；若要调用需要通过get/set方法进行调用

作用：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
提高系统的可维护性

private String name;
    private int id;
    //get set 方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

继承

定义

//子类Students继承父类Person
public class Student extends Person{
    //属性私有
    private int grade;
    //get set 方法
    public int getGrade() {
        return grade;
    }
    public void setGrade(int grade) {
        this.grade = grade;
    }
}

关键字：extends（扩展，子类是父类的扩展）
特点：
- 所有类都继承自Object类
- java只有单继承，没有多继承（只能有一个父类）
- 子类拥有父类的全部方法和属性（前提是public方法和属性）
- private无法继承
- java中所有的类间接或直接继承自object类
- final修饰后不能继承
ctrl+H：调出继承族谱

super

作用：

可以调用父类的属性与方法；继承条件下可以使用

//父类
public class Person {
    protected String name = "Person";//若修饰为private，则super也无法调用
    private int age;
}
//子类
public class Student extends Person{
    private String name="Student";
    private int grade;
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
//main
public class Application {
    public static void main(String[] args) {
        String name="main";
        Student student = new Student();
        student.test(name);
    }
}
//输出
main
Student
Person

特点：
- 子类无参构造默认super调用父类的构造方法
- super调用父类的构造方法，必须在构造方法的第一句
- super必须在子类的方法或者构造方法中
- super和this不能同时调用构造方法
  - this指本类，super指父类

方法的重写

定义

//父类
public class Person {
    public static void test1(){
        System.out.println("Person");
    }
}
//子类
public class Student extends Person{
    //子类重写了父类的test1（）方法
    public static void test1(){
        System.out.println("Student");
    }
}

特点：
- 重写是方法的重写，属性没有重写
- 重写需要有继承关系，子类重写父类的方法
- 方法名相同，参数列表想同
- 修饰符：范围可以扩大不能缩小
- 非静态的，私有的方法不能重写
- 抛出的异常：可以被缩小，但不能扩大
- 方法名一致，方法体不同
作用
- 父类的功能，子类不一定适用

多态

特点：
- 多态是方法的多态，属性没有多态

存在条件：

继承关系，方法需要重写，父类的引用指向子类的对象

 public class Application {
    public static void main(String[] args) {
        //子类引用指向子类对象
        Student student = new Student();
        //父类引用指向子类对象；不能调用子类独有的方法(多态)
        Person student1 = new Student();
        Object student2 = new Student();
    }
}

instanceof

A instanceof B ；

//类关系
//Objec》D
//Objec》B》c
//Objec》B》A
Object Objec= new A();
System.out.println(Object instanceof A);//True
System.out.println(Object instanceof B);//True B被A继承
System.out.println(Object instanceof Objec);//True Objec被A间接继承
System.out.println(Object instanceof C);//C和A无间接或直接继承关系
System.out.println(Object instanceof D);//D和A无间接或直接继承关系
B b= new A();
System.out.println(B instanceof D);//编译报错 B和D无间接或直接继承关系

类转换

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

//向下强制转型（父类转子类）
//Objec》B》A
B a = new A();
B b = (A)a;

//向上自动转型（子类转父类）--可能丢失子类自己本来的方法
A a = new A();
B b = a;

static

特点
- 与类一起加载
- 只执行一次
静态导入包：import static，可以直接导入方法或者属性
静态代码块：static{}，用来赋予初始值

抽象类

abstract修饰的类为抽象类
abstract修饰的方法为抽象方法，只有方法名字，没有方法的实现
接口可以多继承，抽象为单继承
特点：
- 不能new抽象类，只能靠子类继承来实现
- 抽象类中可以写普通方法，抽象方法必须存在抽象类中
- 抽象类的所有方法，继承了他的子类，都必须要实现他的方法（重写），除非子类也抽象

接口

特点：
- 只有规范，无法写普通方法
- 专业的约束：约束和实现分离
- 接口都需要实现类，实现类通过implements实现接口，并且必须重写其所有方法
接口的本质是契约
- interface关键字
接口里的方法默认public abstract，默认常量public static final
implements可以实现多个接口

内部类

可以通过外部类来实例化内部类
可以获得外部类的私有属性
一个Java类中可以有多个类，但只能有一个public类
类的多种写法

posted @ 2020-12-16 12:59 Mr0Fly 阅读(47) 评论(0) 收藏举报

刷新页面返回顶部

Mr0Fly

面向对象的简单概括

面向对象(oop)

类与对象的创建

构造器

创建对象内存分析

封装

继承

super

方法的重写

多态

instanceof

类转换

static

抽象类

接口

内部类

公告