面向对象

面向对象

1.思想

2.面向过程和面向对象的区别

​ 面向过程：今天早上要去上课的完整过程：起床–刷牙–洗脸–出门–打车–走进教室–上课

​ 特点：具体的每一步我们都是参与者，关注的是解决问题的过程

​ 面向对象：洗衣服：将衣服扔进洗衣机里，然后晾衣服，中间没有关注洗衣服的过程

​ 特点：只关注最终的结果

3.面向对象的特点：

A：更符合人们思考问题的方式

B：将我们从执行者变为调用者

C: 将问题简化了

4.举例：

把大象装入冰箱

分析：1.有哪些类（大象 冰箱 OOPDemo）

​ 2.每一个类都有哪些行为（方法）

​ 大象类：吃草

​ 冰箱类：开门，关门

​ OOPDemo：装大象的方法 main

​ 3.类与类之间有怎样的关系

5.源码演示

package org.wdit.OOP;
public class Elephant {    
    public static void eat(){        
        System.out.println("吃食物的行为.....");    
    }    
    public static void walk(){        
        System.out.println("吃食物的行为.....");    
    }
}

package org.wdit.OOP;

public class ICEBox {
    public static void openDoor(){
        System.out.println("打开冰箱");
    }
    public static void closeDoor(){
        System.out.println("关上冰箱");
    }
}

ackage org.wdit.OOP;

public class OOPDemo {
    public static void putin(Elephant elephant){
        System.out.println("装大象");
    }
    public static void main(String[] args){
        //如果使用面向过程的思想解决此问题
        System.out.println("打开冰箱门");
        System.out.println("装入大象");
        System.out.println("关闭冰箱门");

        System.out.println("--------------------------------------------------");
        //使用面向对象的思想解决次问题
        //调用冰箱的开门行为
        ICEBox.openDoor();
        //装入大象
        putin(new Elephant());
        //调用冰箱的关门行为
        ICEBox.closeDoor();

    }
}

6.面向对象的开发设计与特征

开发：不断的创建对象，使用对象，修改对象

设计：管理和维护对象之间的关系。一个好的对象设计，可以实现程序的简化并且易于维护

特征：封装，继承，多态

7.类和对象

类：具有相同属性特征和行为动作的一类事物，统称为类，看不见摸不着，只是一个抽象的概念

对象：万事万物皆对象；能看得见摸得着的东西都是对象

类和对象的关系：对象是类的具体描述，类是对象的抽象

举例：学生

​ 属性：姓名，年龄，性别，体重。。。。

​ 行为：吃饭，走路，说话，学习。。。

属性：描述该事务具有的信息

行为：该事物能干什么

注：java中最基本的单位：类，所以我们就该尝试使用类来描述事物

​ 事物 类

​ 属性 成员变量

​ 行为 成员方法

例如:

学生：类

姓名、年龄、性别、体重：成员变量

走路、吃饭，说话，学习: 成员方法

8.类的使用

定义：

​ 访问修饰符 class 类名{

​ 成员变量

​ 构造方法（无参，有参），默认存在一个隐形的无参构造方法

​ 成员方法

}

类的调用：

​ 1.实例化类 语法：类名 对象名 = new 类名()；//比如: 学生类 tom = new 学生类();

​ 类名 对象名 = new 类名([实参列表])；

​ 2.调用类中的属性： 对象名.属性名 比如： tom.name

​ 3.调用类中的方法：对象目.方法名([实参列表]);

​ 构造方法：用于实例化类的对象的方法为 称为构造⽅法

分为：有参构造⽅法：实例化对象的同时为类中的成员属性进⾏赋值

​ ⽆参构造⽅法：实例化对象的时候对成员属性不进⾏赋值

​ 语法格式：访问修饰符 ⽅法名(){//⽆参构造⽅法

}

​ 访问修饰符 ⽅法名([形参列表]){

​ this.成员属性 = 形参；

​ …

}

注意

1.构造⽅法名必须和其类名同名，

2.没有返回值这⼀说法

3.如果在⼀个类中显示的定义了有参构造⽅法，则隐形⽆参构造将不存在。此时建议将 ⽆ 参构造⽅法显示定义

4.每个类都有构造⽅法，如果没有显示地为类定义构造⽅法，Java编译器将会为该类提供⼀个 默认隐形 ⽆参构造⽅法

5.在创建⼀个类的对象时，⾄少要调⽤⼀个构造⽅法。

6.⼀个类中可以有多个构造⽅法，它们之间构成了重载，即构造⽅法重载。

package org.wdit.OOP;

/**
 * 类的定义及引用
 */
public class Student {
    //成员变量
    String name;
    int age;
    String email;
    String address;
    //无参构造方法显示定义
    public Student(){

    }
    //有参构造方法
    public Student(String name,int age,String email,String address){
        this.name=name;
        this.age=age;
        this.email=email;
        this.address=address;
    }

    //成员方法
    //获取姓名
    public String getName(){
        return name;

    }
    //设置姓名
    public void setName(String name){
        this.name = name;
    }
    //设置并获取年龄

    public int getAge(int age){
        if (age>0 && age<16){
            this.age=16;

        }else{
            this.age=age;
        }
        return this.age;
    }

}

this：代表当前类的对象

⽤途：

1.⽤于区分成员变量和局部变量同名冲突问题

2.可以调⽤当前类的构造⽅法。语法：this([参数列表]); 不传参数在调⽤当前类的⽆参构造⽅法，相反调 ⽤参数列表相吻合的有参构造⽅法。注意：此条调⽤语句必须是⽅法体中的第⼀⾏语句。

3.可以调⽤成员属性：this.成员属性名

4.可以调⽤成员⽅法：this.成员⽅法名([参数列表]);

package org.wdit.OOP;

/**
 * this关键字的应用：
 *  this:代表当前类的对象
 *          * 用途：1.用于区分成员变量和局部变量同名冲突问题
 *          *      2.可以调用当前类的构造方法。语法：this([参数列表])；不传参数在调用当前类的无参构造方法，相反调用参数列表相吻合的有参数列表。
 *          *      注意：此条调用语句必须是方法体中的第一条语句。
 *          *      3.可以调用成员属性：this.成员属性名
 *          *      4.可以调用成员方法：this.成员方法名（[参数列表]）；
 *注意：   this关键字访问类的成员变量和成员方法时不受访问权限的控制
 * 可以访问本类中所有的成员变量和成员方法，包括private的成员变量和成员方法
 */
public class Person {
    String name;
    int age;
    // public Person(){
    // this("tom");
    // }
    //
    // public Person(String name){
    // this();
    // }
    // //以上代码构成了死归问题，就是构造⽅法之间的调⽤没有退出条件
    public Person(){
        this("tom",20);

    }
    public Person(String name){
        this.name = name;
    }
    public Person(String name ,int age){
        //this.age = age;//此⾏代码是为了更好的演示this调⽤构造⽅法时必须为⾸⾏代码的举例
        //this(name);//编译错误：原因：this调⽤当前类中的其他构造⽅法时必须时⽅法体中的⾸⾏代码
        this(name);
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
    public void testMethod(String name){
        this.setName(name);//通过this调⽤了当前类中的其他⽅法
        System.out.println(this.name);
    }
    public static void main(String[] args) {
        Person person = new Person();
        
        System.out.println("--------------this调⽤本类属性-----------------");
        person.setName("tom");
        System.out.println("name1:"+person.name);
        System.out.println("--------------this调⽤本类⽅法-----------------");
        person.testMethod("lily");
        System.out.println("--------------this调⽤本类构造⽅法-----------------");
        Person person1 = new Person("tom",30);
        System.out.println(person1.name);
        System.out.println(person1.age);
    }
}

9.在一个类中可以有以下变量

类变量：存在于类中，方法之外，声明时必须前面添加static关键字：static int flag;随着类的加载而产生

成员变量：

局部变量：

局部变量和成员变量的区别：

1.声明的位置不同

成员变量（实例变量）：类中，方法体外

局部变量：方法体中或方法声明上

2.内存中储存的位置不同

成员变量：位于堆内存中

局部变量：位于栈内存中

3.生命周期不同

成员变量：随着对象的产生而产生，随着对象的消亡而消亡

局部变量：随着方法的调用而产生，随着方法调用完毕而结束

4.初始状态不同

成员变量：有默认的初始化

局部变量：没有默认的初始化，必须手动初始化后，才能使用

5.执行优先级

当成员变量和周期变量同名时，调用时采取“就近原则”