java基础--面向对象编程--2020/10/4

1. 初识面向对象

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

抽象

public class person {
  String name;
  int age;
  //1. 使用new关键字，本质是在调用构造器
  //2. 用来初始化值
  public person(){

  }
  //有参构造：一旦定义了有参构造，无参构造必须显示定义
  public person(String name){
      this.name = name;
  }
}
//构造器：
//   1.和类名相同
//   2. 没有返回值
//  作用
//   1. new 本质在调用构造方法
//   2.初始化对象的值
//注意点：
//   定义了有参构造，如果想使用无参构造，显示定义一个无参的构造
//  ALT +insert
//
// this.    当前类

2 方法回顾

3 对象的创建分析

使用new关键字创建对象
使用new关键字的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
类中的构造器也称为构造方法，实在进行创建对象的时候必须要调用的。并且构造器有一下两个特点：

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

一个类即使什么都不写，他也会存在一个方法
显示的定义构造器

set和get方法

面向对象的三大特性

封装：
程序设计要求“高类聚，低耦合”。高内聚就是累的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
属性私有：get/set
意义：1.提高程序的安全性，保护数据。
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了

public class student {
    //名字
    private String name;
    //学号
    private int num;
    //性别
    private String sex;

    public String getName() {
        return name;
    }

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

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    //学习
    public void study(){
        System.out.println("学习不错");
    }
    //睡觉
    public void sleep(){
        System.out.println("睡觉睡觉");
    }
}

继承：
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
java中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有 “is a”的关系

super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中！
3.super和this不能同时调用构造方法
Vs this：
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提
this ： 没用继承也可以使用
super ： 只能在继承条件才可以使用
构造方法
this（）：本类的构造
super（）：父类的构造

public class Demo01 {
    public static void main(String[] args) {
        student student = new student("sdasd","sd");
        student.test2("asdasd");
    }
}
public class person {

    public person() {
        System.out.println("person无参构造触发了");
    }

    public person(String name) {
        this.name = name;
    }

    private String name = "爸爸";

    public String getName() {
        return name;
    }

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

    private void print() {
        System.out.println("person");
    }

}
public class student extends person {
    public student() {
        System.out.println("student无参构造触发了");

    }

    public student(String name, String name1) {
        super(name);
        this.name = name1;
        System.out.println("student有参构造触发了");
    }

    String name = "儿子";
    public void print(){
        System.out.println("student");
    }
    public void test1(){
        print();
        this.print();


    }
    public void test2(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.getName());
    }
}

方法的重写：
需要有继承关系，子类重写父类的方法
方法名相同，参数列表相同
修饰符：范围可以扩大： public>protcted>default>private
抛出的异常：范围，可以缩小但不能扩大 ；ClassNotFoundException–>Exception

重写子类和父类必要一致；方法体不同！

为什么要重写：
父类的功能，子类不一定需要，或者不一定满足！
Alt+Insert： override 重写

多态：
动态编译：类型：可扩展性
即同一方法可以根据发送的对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件：
有继承关系
子类重写父类的方法
父类引用指向子类对象

注意：多态是方法的多态。属性没有多态性
父类和子类，必须有联系，类型转换异常ClassCastExpection
不能被重写的方法：
Static 方法 ，属于类，他不属于实例
final 常量
private 方法

instanceof

public class Demo01 {
    public static void main(String[] args) {
        /*
        一个对象的实际类型是确定的
        new student
        new person

        可以指向的引用类型就不确定了：父类的引用指向子类
         */
        //Student能调用的方法都是自己的或者继承父类的。
        //person 父类型，可以指向子类，但不能调用子类独有的方法
        student s1 = new student();
        person s2 = new student();
        //能执行那些方法主要看左边的类型，和右边的关系不大
//        s1.run();
//        s2.run();  子类重写了父类的方法，执行子类的方法
        s1.eat();
        ((student) s2).eat();
    }
}

X instanceof Y 编译能不能通过 看X和Y有没有父子关系

引用类型转换： 父 子
子类转换父类可能丢失自己本来的一些方法

1.父类的引用指向子类的对象
2.把子类转换为父类，向上转型；
3.把父类转换为子类，向下转型，强制转换
4.方便方法调用，减少重复的代码！简洁

static：

7 内部类

内部结就是在一个类的内部再定义一个类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类