面向对象理论

面向对象

类与对象

构造器

性质：

1. 和类名相同
2. 没有返回值

作用:

1. new 本质在调用构造方法
2. 初始化对象的值

注意点：

1. 定义有参构造后，如果想使用无参构造，必须再定义一个无参的构造
2. 没做任何定义之前，默认存在一个无参构造
3. 构造函数 类名 对象名 = new 类名（）； 不要忘记括号，此为构造方法

this. =

面向对象的三大特征

1. 封装
2. 继承
3. 多态

封装

内部属性private私有

private 定义内部属性

提供外部public的方法

get 获得这个数据

public String getName(){
    return this.name;
}

set 给这个数据设置值

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

可以通过内部的封装让程序变得更安全

public void setAge(int age){
    if(age>120||age<0){
    this.age = 3;
    }else{
        this.age = age;
    }
}

封装的意义

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性增加了

继承

extends

1. 只有单继承，没有多继承
2. private 无法被继承

Object类

Java中所有类的默认继承了Object类

super

public void test(String name){
    System.out.println(name);       //输入的
    System.out.println(this.name);  //当前子类中的
    System.out.println(super.name); //父类中的
}

public student(){
    //super();    隐藏代码调用了父类的构造
    //			  而且调用父类的构造器必须在子类构造器的第一行				
    System.out.println("xxx");
}

注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super 和 this 不能同时调用构造方法

final

使用final修饰词后，类就不能在被继承。

重写@override

：需要有继承关系，子类继承父类的方法

---

注意点：

1. 方法名必须相同；
2. 参数列表必须相同； 即方法头相同，方法体不同
3. 修饰符：范围可以扩大但不能缩小；
4. 抛出的异常：范围可以缩小，但不能扩大；

多态

1. 即同一方法可以根据发送的对象的不同而采用多种不同的行为方式

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

3. 动态编译：可扩展性更强

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

---

public class Person{
    public void run(){
        System.out.println("father");
    }
}

public class Student{
    @Override
    public void run（）{
        System.out.println("son");
    }
    
    public void eat(){
        System.out.println("eat");
    }
}

//一个对象的实际类型是确定的
//可以指向的引用类型就不确定了：父类的引用指向子类


//Student 能调用的方法都是自己或者继承父类的！
Student s1 = new Student();
//Person 父类，可以指向子类，但不能调用子类独有的方法
Person  s2 = new Student();
Object  s3 = new Student();



//对象能执行那些方法，主要看对象左边的类型，和右边关系不大！
((Student)s2).eat();
s1.eat();
//子类重写了父类的方法，执行子类的方法
s1.son();     //--->"son"
s2.son();     //--->"son"

存在条件

1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类对象

instanceof 方法

  Object obj =new Student();
//Object >> Person >>  Student
//在同一条支线上，使用instanceof方法就输出true，否则输出false
System.out.println(obj instanceof Student);  //---->true
System.out.println(obj instanceof Object);   //---->true
System.out.println(obj instanceof Person);   //---->true
System.out.println(obj instanceof String);   //---->false
System.out.println(obj instanceof Teacher);  //---->false

类型转换

1. 父类引用指向子类对象
2. 把子类转换成父类，向上转型
3. 把父类转换成子类，向下转型，强制类型转换

static

1. static 定义属性和方法，可以直接调用类来使用；否则要创建对象后再调用

2. 静态类最先加载

3. 非静态方法中可以调用静态方法；但静态方法中只能直接调用静态方法:new Student()，若调用非静态方法需要先使用构造器创建对象然后调用方法： new Student( ). test( );

4. 静态代码块

static{
    //静态代码块
    //只执行一次
}

{
    //匿名代码块
}