面向对象--封装、继承、多态

面向对象

以类的方式组织代码，以对象的组织封装数据

三大特性：

• 封装
• 继承
• 多态

类：抽象的数据类型 对象：抽象概念的具体事例

构造器用于初始化值 |(默认)无参构造|有参构造

public 类名(){}  //无返回值

---

封 装

隐藏内部细节，提高代码安全性，保护数据

统一接口，增加系统可维护性

public class Main {
  public static void main(String[] args) {
    Student student = new Student();
    student.setName("小明");//赋值
    student.setAge(22);
    System.out.println(student.getName());
    System.out.println(student.getAge());
  }
}

 class Student{
    private String name;  //属性私有化
    private int age;
    //get方法 设置
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    //set方法 获取
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
}

---

继 承

java 类中只有单继承，没有多继承，可多重继承

子类继承父类的功能，并且可以新增自身特有的功能

class Main {
  public static void main(String[] args) {
    Student student = new Student(); 
    student.say();
    student.print();
  }
}

public class Person {
    public void say(){       
        System.out.println("人在说话！");
    }
}
//子类继承父类
public class Student extends Person{
    @Override
    public void say(){
        System.out.println("学生在说话！");  //子类重写父类方法
    }
    public void print(){
        say();
        this.say();//调用当前
        super.say();//调用父类
    }
}

---

多态

必备条件：继承关系，父类引用指向子类对象,方法需要重写

子类转换成父类，向上转型；父类转换成子类，向下转型，需要强制转换，易丢失精度

public class Person {
    public void say(){
        System.out.println("人在说话！");
    }
}
public class Student extends Person{
    @Override
    public void say(){
        System.out.println("学生在说话！");
    }  
}
class Main {
  public static void main(String[] args) {
    Person  person = new Student(); //父类 对象名 = new 子类
    person.say();				//编译看左，运行看右
  }
}

//instanceof关键字 判断两个类型是否是继承关系
Object object = new Student();
System.out.println(object instanceof Student);//ture

static{
    //静态代码块（与程序一同执行，只执行一次）
}

抽象类abstract

//方法的抽象只有方法名,无需实现具体
//抽象类无法new出来，只能靠它的子类实现出来
//抽象方法必须在抽象类中
public abstract void add();/抽象方法

接口interface

//比抽象更抽象，可以多继承，
//无法实例化，必须重写接口中所有方法
 void add();

内部类

//内部类可以获取外部类的private等
public class Outer {
    public void out(){
        System.out.println("在外面！");
    }
    public class Inner{//内部类
        public void in(){
            System.out.println("在里面！");
        }
    }
}
class Main {
  public static void main(String[] args) {
    Outer outer = new Outer();//需要先实例化外部的才能用内部的
    Outer.Inner inner = outer.new Inner();
    inner.in();
  }
}

异常

try{
    //try监控，可能出现异常
}catch(Exception e){
    //catch捕获异常
}finally{
    //处理善后工作，必执行的部分
}

throw  //主动抛出异常，用于方法中
throws //方法上抛出异常