java基础：面向对象（一）

一、概念

• 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题!
• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分布，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
• 面向对象编程（Object-Oriented Programming，OOP）
• 面向对象的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据
• 抽象
• 三大特性：封装、继承、多态
• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类,是抽象的，是对对象的抽象
• 从代码运行角度考虑是先有类后有对象。类是对象的模板。

二、方法调用

1、静态方法（static）和非静态方法（不加static）
如果是在一个类中（Demo01类）调用另一个类（Student类）的静态方法，直接在Demo01中调用；如果是非静态方法就需要现在Demo01中实例化这个类。

public class Student{
    //静态方法
    public static void say(){
        System.out.println("学生在说话！");
    }
    //非静态方法
    public void move(){
        System.out.println("学生在动！");
    }
}

public class Demo01{
    puclic static void main(String[] args){
        //调用静态方法
        Student.say();
        
        //调用非静态方法
        //先实例化 对象类型 对象名 = 对象值;
        Student student = new Student();
        Student.move();
        
    }
}

原因：在同一个类中，普通方法a();可以直接调用普通方法b();，静态方法a()也可以直接调用静态方法b(),但是当一个是静态方法一个是普通方法是没办法调用。static是和类一起加载的，而普通方法是类实例化之后才存在的，所以一个静态方法（已经存在的）调用一个普通方法（现在还不存在的）就会报错。

2、形参和实参：在创建方法时传入的参数，是没有实际值的，叫形参，而调用该方法是，传入了实际的值叫实参。

3、this关键字

三、类和对象的创建

（一）基本概念

1、类和对象的关系：类是一种抽象的数据类型，它是对某一类事物整体描述/定义（如动物、植物、人等），但是并不能代表某一个具体的事物。对象是抽象概念的具体事例（如张三就是人的一个具体实例，张三家的狗旺财就是狗的一个具体实例），能够展现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

2、创建与初始化对象

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

3、一个类中只存在：属性和方法。

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

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

//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
public class Main {
    public static void main(String[] args) {

        //类是抽象的，需要实例化,new了之后就已经实例化了
        //类实例化后会返回一个自己的对象
        //student对象就是Student类的一个具体实例
        //Student student = new Student();
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 5;

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

        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
    }
}

从输出结果可以看出，通过new关键字实例化对象。

（二）构造器

类中构造器也称构造方法，是在进行创建对象的时候必须调用的，并且构造器有以下两个特点：必须和类名相同、必须没有返回类型，也不能写void（构造器必须掌握）
注：不要在每一个类里面都加一个main方法，一个程序里面只有一个main方法。 所以我们可以定义一个大的启动类，并将main方法写在这个启动类里面。

public class Main {
    public static void main(String[] args) {

        //类是抽象的，需要实例化,new了之后就已经实例化了
        //类实例化后会返回一个自己的对象

        //使用new实例化一个Person对象
        Person person = new Person();
        System.out.println(person.name);
    }
}

public class Person {
    String name;
    //一个类即使什么都不写，它也会存在一个方法
}

我们发现此时即使什么也不写，依旧会输出，我们把Person加入构造器

public class Person {
    String name;
    //一个类即使什么都不写，它也会存在一个方法

    //实例化初始值(构造器与类名相同，没有返回值，也没有void)
    public Person(){
        this.name = "yours_Gabriel";
    }
}

通过断点调试，我们发现代码运行过程是：mian（new）——>跳转到构造器——>跳回main，才生成一个对象，在此可以清晰的认识到构造器的作用：1、使用new关键字，必须要有构造器（new一个对象的话，本质是在调用构造器）2、构造器一般用来初始化值

public class Person {
    String name;
    //一个类即使什么都不写，它也会存在一个方法

    //实例化初始值(构造器与类名相同，没有返回值，也没有void)
    public Person(){
        this.name = "yours_Gabriel";
    }
    //有参构造：一旦定义了有参构造，无参就必须显示定义，也就是说必须在person类中将无参构造写出来
    //此时main中Person person = new Person();语句就会报错
    public Person(String name){
        this.name = name;
    }
}

alt+insert：快捷键生成构造器（有参、无参均可，有参直接点击ok，无参点击“select no”）

（三）封装

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

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

3、作用：提高程序的安全性、隐藏代码的实现细节、统一接口、增加系统的可维护性

4、私有属性：get/set

public class Main {
    public static void main(String[] args) {

        Student s1 = new Student();
        s1.setName("yours_Gabriel");
        System.out.println(s1.getName());
    }
}

public class Student {

    //私用属性，外部没法调用
    private String name;//名字
    private int id;//学号
    private char sex;//性别

    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法
    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
}

alt + insert：自动生成get \set 方法

（四）继承

1、继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

2、extands的意思是“扩展”。子类是父类的扩展。在子类的实现中，默认调用了父类的无参构造。调用父类的构造器必须要在子类构造器的第一行。

main函数中：

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

Person类中

public class Person {
    public void say(){
        System.out.println("这是父类的人在说话");
    }
}

Student类中：

public class Student extends Person{

}

输出结果：

说明子类继承了父类就会拥有父类的全部方法。前提是在“public”的情况下，私有的情况下无法继承，一般情况下属性是私有的

“ctrl + H”:可以查看继承的情况

3、JAVA中类只有单继承，没有多继承!

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

5、继承关系的俩个类，一个为子类(派生类)一个为父类(基类)。子类继承父类,使用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系.

6、object类
在java中，所有的类都默认继承与“Object”类。

7、super（调用父类的方法和属性，私有的属性、方法无法被调用）

• super调用父类的构造方法，必须在构造方法的第一个。（第一个调用）
• super必须只能出现在子类的方法或者构造方法中
• super和this不能同时调用构造方法

和 this 进行比较

• 代表对象不同：this是本身调用这个对象，super代表父类对象的应用
• 前提：this是没有继承也可以使用，super只有在继承条件才可以使用
• 构造方法：this（）本类的构造，super（）是父类的构造

8、重写（都是方法的重写，和属性无关，方法的属性也必须是public）
main中

//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
public class Main {
    public static void main(String[] args) {
        //方法的调用只和左边定义的数据类型有关
        Student student = new Student();
        student.test();

        //父类的引用指向了子类
        Person person = new Student();
        person.test();
    }
}

父类中

public class Person {
    public static void test(){
        System.out.println("Person=>test");
    }
}

子类中

public class Student extends Person{

    public static void test(){
        System.out.println("Student=>test");
    }

}

在子类中重载也可以使用快捷键 alt + insert

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

• 方法名必须相同
• 参数列表必须相同
• 修饰符：范围可扩大但是不能缩小 public > Protected > Default >private
• 抛出的异常：范围可以被缩小，但不能被扩大
• 子类的方法必须和父类一致，但方法体不同