面向对象

1.面向对象的概念

• 面向对象编程（object-oriented programming,OOP)：利用抽象、封装等机制，借助于对象、类、继承、消息传递等概念进行软件系统构造的软件开发方法。

• 其本质是：以类的方式组织代码，以对象封装数据。

• 抽象

三大特性：

• 封装：将数据和代码捆绑到一起，对象的某些数据和代码可以是私有的，不能被外界访问，以此实现对数据和代码不同级别的访问权限。

• 继承：子类继承父类的特征和行为，使得子类对象具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

• 多态：不同事物具有不同表现形式的能力。

2.类与对象

public class Student {
    String name;
    int age;
​
    public void study(){
        System.out.println("正在学习！");
    }
​
}
​
public class ApplicationTest {
    public static void main(String[] args) {
        Student s1 = new Student();
​
        s1.name="张三";
        s1.age=16;
​
        System.out.println(s1.name);
        System.out.println(s1.age);
    }
}
​

3.构造器

构造器用于在创建对象时初始化对象。

public class Person {
    String name;
    int age;
​
    public Person() {
    }
​
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
​
public class ApplicationTest {
    public static void main(String[] args) {
        Person person = new Person();
​
        person.name="zhangsan";
        person.age=12;
        System.out.println(person.name);
        System.out.println(person.age);
​
        Person person1 = new Person("ni", 12);
        System.out.println(person1.name);
        System.out.println(person1.age);
    }
}
​

3.内存机制

• 堆（heap)：

  所有对象

• 栈（stack):

  局部变量和方法调用

• 方法区

4.封装

程序设计要追求“高内聚、低耦合”，高内聚就是累的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

属性私有：get/set

public class Person {
    private String name;
    private int age;
    private String id;
​
    public Person() {
    }
​
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getId() {
        return id;
    }
​
    public void setId(String id) {
        this.id = id;
    }
}
​

public class ApplicationTest {
    public static void main(String[] args) {
        Person person = new Person();
​
        person.setName("张三");
        person.setId("10024");
        person.setAge(12);
​
        System.out.println(person.getName());
        System.out.println(person.getId());
        System.out.println(person.getAge());
    }
}
​

5.继承

• 在Java中，只有单继承，不存在多继承。

• 继承是类与类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。

• 子类和父类之间是“is a”的关系

public class Student extends Person{
    public static void main(String[] args) {
        Person person = new Person();
        person.eat();
    }
}
​

关于super调用：

1. super调用父类构造方法，必须在构造方法的第一个；

2. 只能出现在子类的方法或构造方法中。

3. super和this不能同时调用构造方法。

重写（overwrrite)：

父类的功能，子类不一定需要，或者不一定满足。

要求：

1. 方法名相同

2. 参数列表相同

3. 修饰符范围可扩大但不可缩小

4. 抛出异常范围可扩大但不可缩小。

6.多态

public class Student extends Person{
    @Override
    public void eat() {
        System.out.println("好吃");
    }
    
    public void sleep(){
        System.out.println("Sleeping!");
    }
}
​

public class ApplicationTest {
    public static void main(String[] args) {
        Student s1=new Student();
        Person s2 = new Student();
​
        s2.eat();
        ((Student) s2).sleep();
    }
}
​

instanceof和类型转换

instanceof类型转换，判断一个对象是什么类型。

1. 把子类转换成父类，向上转型自动转换

2. 父类转换成子类，向下转型，强制转换

抽象类与接口

• 抽象类可以没有抽象方法，但抽象方法一定要声明抽象类。

• 子类继承抽象类，那么就必须实现抽象类没有实现的抽象方法，否则该子类也必须是抽象类。

• 接口不能被实例化，接口中没有构造方法，接口可多实现。