标签：07 name void 面向对象编程父类方法 public String

Java 的核心思想就是 OOP（面向对象编程）

1.面向对象

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

2.对象的创建

2.1.创建与初始化对象

创建对象：new
使用 new 关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。
构造器特点：

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

Application.java：

public class Application {
    public static void main(String[] args) {
        // 类：抽象的，实例化
        // 类实例化后会返回一个自己的对象
        // student 对象就是一个 Student 类的具体实例
        Student student = new Student();

        student.name = "小明";
        student.age = 13;

        System.out.println(student.name);
        System.out.println(student.age);

    }
}

Student.java

public class Student {
    // 属性：字段
    String name; //null
    int age; //0

    // 方法
    public void study(){
        System.out.println(this.name + "在学习");
    }

}

2.2.构造器详解

Person.java

public class Person {
    // 一个类即使什么都不屑，也会存在一个方法
    // 显示的定义构造器
    String name;
    //实例化初始值
    //1.使用 new 关键字，本质是在调用构造器
    //2.用来初始化值
    public Person(){
        this.name = "小红";
    }
    // 有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }

    //快捷键：Fn + Alt + Insert
}

3.面向对象三大特性

封装、多态、继承

3.1.封装

高内聚，低耦合：高内聚-类的内部数据操作细节自己完成，不允许外部干涉；低耦合-仅暴露少量的方法给外部使用。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
Student.java

public class Student {
    // 属性私有
    private String name; //名字
    private int id;//学号
    private char sex;//性别

    //提供一些可以操作这个属性的方法
    //提供一些 public 的 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;
    }

    public char getSex() {
        return sex;
    }

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

application.java

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("小明");
        s1.setId(10001);
        s1.setSex('男');
        System.out.println(s1.getName() + " " + s1.getId() + " " + s1.getSex());
    }
}

3.2.继承

关键字：extands（扩展，子类是父类的扩展）
Java 中类只有单继承，没有多继承
继承关系两个类：子类（派生类），父类（基类，子类继承父类
子类拥有父类的全部方法（一般需要 public）
快捷键：Ctrl+h（查看此类的继承）
在 java 中，所有的类都默认直接或间接继承 Object

super：调用父类的属性或方法（如：super.name，私有的东西无法被继承）
this：调用当前类中的属性或方法
super注意点：

super 调用父类的构造方法，必须在构造方法的第一个；
super 必须只能出现在子类的方法或者构造方法中；
super 和 this 不能同时调用构造方法
VS this：
代表的对象不同：
    this：本身调用这个对象
    super：代表父类对象的应用
前提：
    this：没有继承也能使用
    super：只能在继承条件才可以使用
构造方法：
    this()：本类的构造
    super()：父类的构造

方法重写
重写都是方法的重写，和属性无关
父类的引用指向了子类
方法的调用只和定义的数据类型有关
Override：重写

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

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大（public > protected > default > private)
抛出的异常：范围可以缩小，但不能扩大（ClassNotFoundException --> Exception(大)）

快捷键：Fn + Alt + Insert --> Override

3.3.多态

多态是方法的多态，属性没有多态
父类和子类有联系（类型转换异常：ClassCastException）
存在条件：继承条件，方法需要重写，父类引用指向子类对象

对象能执行哪些方法：主要看对象左边的类型，和右边关系不大

不能被重写：
static 方法：属于类，不属于实例
final：常量
private：私有的

instanceof
x instanceof y：类型转换，判断x与y是否有关系

//Student extands Person
//Teacher extands Person
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false

总结：

父类引用指向子类的对象
把子类转换为父类，向上转型
把父类转换为子类，向下转型，强制转换
方便方法的调用，减少重复的代码

4.抽象类和接口

4.1.抽象类

关键字：abstract
抽象方法：只有方法名字，没有方法的实现
特点：

不能 new 这个抽象类，只能靠子类去实现它：约束
抽象类中可以写普通的方法
抽象方法必须在抽象类中

4.2.接口

关键字：interface
接口：只有规范，自己无法写方法；约束和实现分离：面向接口编程
作用：

约束
定义一些方法，让不同的人实现
方法都是抽象的：public abstract
属性都是常量：public static final
接口不能被实例化，接口中没有构造方法
可以实现多个接口
必须要重写接口中的方法

UserServer.java


// interface 定义的关键字，接口都需要有实现类
public interface UserServer {
    //所有的属性都是常量 public static final
    int AGE = 99;

    // 接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

TimeServer.java

public interface TimeServer {
    void timer();
}

UserServerImpl.java


// 实现了接口的类，就需要重写接口中的方法
// 多继承：利用多个接口实现多继承
public class UserServerImpl implements UserServer,TimeServer{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

5.内部类及 OOP 实战

内部类：在一个类的内部再定义一个类；比如，A类中定义了一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了
Outer.java

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

Application.java

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
}

标签：07,name,void,面向对象编程,父类,方法,public,String
From： https://www.cnblogs.com/luoluostudy/p/18173643

07.面向对象编程