面向对象的复习

面向对象

一、面向对象的本质：以类的方式组织代码，以对象形式封装数据

面向对象的三大特性：封装、继承、多态

从认识论角度考虑是先有对象后有类，对象是具体的事物，类是抽象的，是对对象的抽象

比如说，先有了人（对象），再有教师（类）、学生（类）等等

举个例子：Demo01类：（实例化类的快捷键：alt+enter）

package com.oop.demo01;
//Demo01类
public class Demo01 {
    //一个真正的程序里面只有一个main方法
    public static void main(String[] args){
        Student.say();//调用其他类中的静态方法是：类名.方法名

        //调用student类中的非静态方法：实例化这个类 new
        //对象类型  对象名字  =  对象值
        Student student = new Student();
        //快捷键：alt+enter
        //调用非静态方法：对象名称.方法();
        student.say2();
    }
}

Student类：

package com.oop.demo01;
//学生类
public class Student {
    //静态方法
    public static void say(){
        System.out.println("学生说话了");
    }
    //非静态方法，没有static关键字
    public void say2(){
        System.out.println("学生下课了");
    }
}

三、在同一个类中调用方法：

package com.oop.demo01;

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

    }
    //两个都是静态方法的时候，a可以调用b方法
    //static和类一起加载的
    public static void a(){
        b();//如果b方法没有static的话，那么就会报错
    }
    //类实例化之后才存在
    public static void b(){

    }
}

值传递：

package com.oop.demo01;

public class Demo02 {
    //值传递
    public static void main(String[] args){
        int a = 1;
        System.out.println(a);
        Demo02.change(a);//调用方法
        System.out.println(a);//输出结果：a=1
    }
    public static void change(int a){//注意void，返回值为空，不会将a=10传回去
        a = 10;
    }
}

引用传递：

package com.oop.demo01;

public class Demo02 {
    //引用传递
    public static void main(String[] args){
        Person person = new Person();//实例化
        System.out.println(person.name);//输出null
        Demo02.change(person);
        System.out.println(person.name);//输出liyan
    }
    public static void change(Person person){
        //person是一个对象，指的是Person person = new person();
        person.name = "liyan";
    }
}

//定义了一个Person类，有一个属性：name
class Person{
    String name;//null
}

四、类与对象的关系

类是一种抽象的数据类型，是对某一类事物整体描述\定义，但是不能代表某一个具体事务

对象是抽象概念的具体实例：张三就是一个人的具体实例

1）、创建与初始化对象：使用new关键字创建对象

在student类中的代码：

package com.oop.demo01;
//学生类
public class Student {
    //属性：字段
    String name;//默认值：null
    int age;//默认值：0
    
    //方法
    public void study(){
        System.out.println(this.name+"学生在学习");
    }
}

在Application类中的代码：

package com.oop.demo01;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args){
        //类：是抽象的，需要实例化
        //类实例化之后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
        Student xiaoming = new Student();
        Student xh = new Student();
        xiaoming.name = "小明";
        xiaoming.age = 10;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xh.name = "小红";
        xh.age = 13;
        System.out.println(xh.name);
        System.out.println(xh.age
        );
    }
}

五、构造器

Person类中：

package com.oop.demo01;

public class Person {
    //一个类即使什么都不写，他也会存在一个方法
    //显式定义构造器
    String name;
    //实例化初始值
    //1.使用new关键字，必须要有构造器
    public Person(){
        this.name = "abc";
    }
    //有参构造：一旦定义了有参构造，无参构造就必须显式定义
    public Person(String name){
        this.name = name;//this.name指的是第六行的name，而等号右边的name指的是13行参数里面的name
    }
    //也就是说，有参无参构造都一起写上
    //快捷键：alt+insert：来创建有参和无参构造
    
    /*
    总结：
    构造器：与类名相同，无返回值
    作用：
    1.new本质在调用构造方法
    2.初始化对象的值
    注意点：
    1.有参无参都要写上
    2.this.指的是当前类的，而等号后面的是参数传进来的值
     */
}

Application类中：

package com.oop.demo01;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args){
        //new 实例化了一个对象
        Person person = new Person();

        System.out.println(person.name);//输出abc
    }
}

总结：
构造器：与类名相同，无返回值
作用：
1.new本质在调用构造方法
2.初始化对象的值
注意点：
1.有参无参都要写上
2.this.指的是当前类的，而等号后面的是参数传进来的值

其他知识点：

对象的创建与使用：

1、必须使用new关键字创建对象，构造器：Person liyan = new Person();

2、对象的属性：liyan.name

3、对象的方法：liyan.sleep();

类：

静态的属性 属性

动态的方法 方法