面向对象和封装

面向对象和封装

面向对象思想的概述

面向过程：当需要实现一个功能的时候，每一个具体的步骤需要亲力亲为，详细处理每一个细节。

面向对象：当需要实现一个功能的时候，不关心具体步骤，找一个具有该功能的代码来完成。

示例：

题目：以[15，20，25，30，50]的样式打印出数组

import java.util.Arrays;

public class FaceTo {
    public static void main(String[] args) {
        int [] arrayA= {15,20,25,30,50};
        //面向过程
        System.out.print("[");
        for (int i = 0; i < arrayA.length ; i++) {
            if (i == arrayA.length - 1) {
                System.out.println(arrayA[i] + "]");
            } else {
                System.out.print(arrayA[i] + "，");
            }
        }
        //面向对象
        System.out.println(Arrays.toString(arrayA));
    }
}

类和对象的关系

类：是一组相关属性和行为的集合，可以看成是一类食物的模板，使用事物的属性特征和行为特征来描述该类事物。

• 属性：事物的状态信息。
• 行为：事物能够做什么。

类与对象的关系

• 类是对一类事物的描述，是抽象的。
• 对象是一类事物的实例，是具体的。
• 类是对象的模板，对象是类的实体。

类的定义

public class Student {
    //成员变量
    int age;
    String name;
    //成员方法
    public void eat(){
        System.out.println("吃饭！");
    }
    public void sleep(){
        System.out.println("睡觉！");
    }
}

注意事项

1. 成员变量是直接定义在类当中，在方法外。
2. 成员方法不写 static 关键字。

对象的创建及其使用

通常情况下：一个类并不能直接使用，需要根据类创建一个对象，才能使用。

1. 导包 ：指出需要使用的类，在什么位置。

   import 包名称.类名称；

   对于和当前类属于同一个包的情况，可以省略导包语句不写。

2. 创建 ：

类名称 对象名 = new 类名称 ();

3. 使用：

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名(参数)

public class DuiXiang {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "上进威龙";
        stu.age = 19;
        System.out.println(stu.age);
        System.out.println(stu.name);
        stu.eat();
        stu.sleep();
    }
}

手机类练习

package Phone;

public class Phone {
    //定义成员变量
    String brand;
    double price;
    String color;
    //定义成员方法
    public void call (String who){
        System.out.println("给"+who+"打电话！");
    }
    public void sendMessage (String who){
        System.out.println("给"+who+"发短信！");
    }
}

package Phone;

public class PhoneOne {
    public static void main(String[] args) {
        //创建对象
        Phone One = new Phone();
        One.brand = "苹果";
        One.price = 7880;
        One.color = "玫瑰金";
        System.out.println("品牌："+One.brand);
        System.out.println("配色："+One.color);
        System.out.println("价格："+One.price);
        One.call(" 上进威龙 ");
        One.sendMessage(" Veyron ");
    }
}

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

1. 定义的位置不同。

成员变量：在方法的内部

局部变量：在方法的外部，直接写在类当中

2. 作用范围不同

局部变量：只有方法当中才能使用

成员变量：整个类都可以通用

3. 默认值不同

局部变量：没有默认值，如果要想使用，必须手动进行赋值

成员变量：如果没有赋值，会有默认值，规则和数组一样

4. 内存的位置不同

局部变量：位于栈内存

成员变量：位于堆内存

5. 生命周期不同

局部变量：随着方法进栈而诞生，随着方法出栈而消失

成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

封装性

面向对象三大特征：封装、继承、多态。

封装性在Java当中的体现：

1. 方法就是一种封装
2. 关键字private也是一种封装

练习 使用private关键字

public class Student {
    private int age;
    private String name;
    private boolean male;
    public void setAge(int num){
        age = num;
    }
    public int getAge(){
        return age;
    }
    public void setName(String str){
        name = str;
    }
    public String getName(){
        return name;
    }
    public void setMale(boolean a){
        male = a;
    }
    public boolean isMale(){
        return male;
    }
}

public class Stu {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setAge(18);
        stu.setName("上进威龙");
        stu.setMale(true);
        System.out.println("年龄："+stu.getAge());
        System.out.println("姓名："+stu.getName());
        System.out.println("是否为男性："+stu.isMale());
    }
}

this关键字的作用

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。

如果需要访问本类当中的成员变量，需要使用格式： this.成员变量名

public class Sjwl {
    String name;
    public void Hello(String name){
        System.out.println(name+"你好，我是："+this.name);
    }
}

public class People {
    public static void main(String[] args) {
        Sjwl peo = new Sjwl();
        peo.name = "上进威龙";
        peo.Hello("马云");
    }
}

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

格式：

public 类名称(参数类型 参数名称){
方法体
}

注意事项：

1. 构造方法的名称必须和所在的类名称完全一样。
2. 构造方法不写返回值类型。
3. 构造方法不能return一个具体的返回值。
4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么都不做。
5. 一旦编写了至少一个构造方法，那么编译器将不再赠送。

package demo01;

public class Student {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("姓名："+name+"年龄："+age);
    }
}

package demo01;

public class demo01Student {
    public static void main(String[] args) {
        Student stu = new Student("上进威龙",20);
    }
}

定义一个标准的类

一个标准的类通常要拥有下面四个组成部分：

1. 所有的成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一对儿Getter/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法

这样标准的类也叫作 Java Bean

package demo01;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    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;
    }
}

package demo01;

public class demo01Student {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("上进威龙");
        stu1.setAge(20);
        System.out.println("姓名："+stu1.getName()+"，年龄："+stu1.getAge());
        System.out.println("=======================================");

        Student stu2 = new Student("曹威龙",19);
        System.out.println("姓名："+stu2.getName()+"，年龄："+stu2.getAge());
        stu2.setAge(18);
        System.out.println("姓名："+stu2.getName()+"，年龄："+stu2.getAge());
    }
}
t.println("姓名："+stu1.getName()+"，年龄："+stu1.getAge());
        System.out.println("=======================================");

        Student stu2 = new Student("曹威龙",19);
        System.out.println("姓名："+stu2.getName()+"，年龄："+stu2.getAge());
        stu2.setAge(18);
        System.out.println("姓名："+stu2.getName()+"，年龄："+stu2.getAge());
    }
}