面向过程

面向过程

当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。 面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

package cn.itcast.day06.demo01;
import java.util.Arrays;
public class Demo01PrintArray {
​
•   public static void main(String[] args) {
•       int[] array = { 10, 20, 30, 40, 50, 60 };
​
•       // 要求打印格式为：[10, 20, 30, 40, 50]
•       // 使用面向过程，每一个步骤细节都要亲力亲为。
•       System.out.print("[");
•       for (int i = 0; i < array.length; i++) {
•           if (i == array.length - 1) { // 如果是最后一个元素
•               System.out.println(array[i] + "]");
•           } else { // 如果不是最后一个元素
•               System.out.print(array[i] + ", ");
•           }
•       }
•       System.out.println("==============");
​
•       // 使用面向对象
•       // 找一个JDK给我们提供好的Arrays类，
•       // 其中有一个toString方法，直接就能把数组变成想要的格式的字符串
•       System.out.println(Arrays.toString(array));
•   }
​
}

类与对象

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

1. 导包：也就是指出需要使用的类，在什么位置。 import 包名称.类名称; import cn.itcast.day06.demo01.Student; 对于和当前类属于同一个包的情况，可以省略导包语句不写。

2. 创建，格式： 类名称 对象名 = new 类名称(); Student stu = new Student();

3. 使用，分为两种情况： 使用成员变量：对象名.成员变量名 使用成员方法：对象名.成员方法名(参数) （也就是，想用谁，就用对象名点儿谁。）

注意事项： 如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

package cn.itcast.day06.demo01;
public class Demo02Student {
​
  public static void main(String[] args) {
      // 1. 导包。
      // 我需要使用的Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写
​
      // 2. 创建，格式：
      // 类名称 对象名 = new 类名称();
      // 根据Student类，创建了一个名为stu的对象
      Student stu = new Student();
​
      // 3. 使用其中的成员变量，格式：
      // 对象名.成员变量名
      System.out.println(stu.name); // null
      System.out.println(stu.age); // 0
      System.out.println("=============");
​
      // 改变对象当中的成员变量数值内容
      // 将右侧的字符串，赋值交给stu对象当中的name成员变量
      stu.name = "赵丽颖";
      stu.age = 18;
      System.out.println(stu.name); // 赵丽颖
      System.out.println(stu.age); // 18
      System.out.println("=============");
​
      // 4. 使用对象的成员方法，格式：
      // 对象名.成员方法名()
      stu.eat();
      stu.sleep();
      stu.study();
  }
​
}
定义一个类，用来模拟“学生”事物。其中就有两个组成部分：

属性（是什么）： 姓名 年龄 行为（能做什么）： 吃饭 睡觉 学习

对应到Java的类当中：

成员变量（属性）： String name; // 姓名 int age; // 年龄 成员方法（行为）： public void eat() {} // 吃饭 public void sleep() {} // 睡觉 public void study() {} // 学习

注意事项：

1. 成员变量是直接定义在类当中的，在方法外边。

2. 成员方法不要写static关键字。

package cn.itcast.day06.demo01;
public class Student {
​
•   // 成员变量
•   String name; // 姓名
•   int age; // 姓名
​
•   // 成员方法
•   public void eat() {
•       System.out.println("吃饭饭！");
•   }
​
•   public void sleep() {
•       System.out.println("睡觉觉！");
•   }
​
•   public void study() {
•       System.out.println("学习！");
•   }
​
}

 

package cn.itcast.day06.demo02;
​
public class Demo01PhoneOne {
​
  public static void main(String[] args) {
      // 根据Phone类，创建一个名为one的对象
      // 格式：类名称 对象名 = new 类名称();
      Phone one = new Phone();
      System.out.println(one.brand); // null
      System.out.println(one.price); // 0.0
      System.out.println(one.color); // null
      System.out.println("=========");
​
      one.brand = "苹果";
      one.price = 8388.0;
      one.color = "黑色";
      System.out.println(one.brand); // 苹果
      System.out.println(one.price); // 8388.0
      System.out.println(one.color); // 黑色
      System.out.println("=========");
​
      one.call("乔布斯"); // 给乔布斯打电话
      one.sendMessage(); // 群发短信
  }
​
}

package cn.itcast.day06.demo02;
​
public class Demo04PhoneParam {
​
  public static void main(String[] args) {
      Phone one = new Phone();
      one.brand = "苹果";
      one.price = 8388.0;
      one.color = "土豪金";
​
      method(one); // 传递进去的参数其实就是地址值
  }
​
  public static void method(Phone param) {
      System.out.println(param.brand); // 苹果
      System.out.println(param.price); // 8388.0
      System.out.println(param.color); // 土豪金
  }
​
}

package cn.itcast.day06.demo02;
​
/*
定义一个类，用来模拟“手机”事物。
属性：品牌、价格、颜色
行为：打电话、发短信
​
对应到类当中：
成员变量（属性）：
  String brand; // 品牌
  double price; // 价格
  String color; // 颜色
成员方法（行为）：
  public void call(String who) {} // 打电话
  public void sendMessage() {} // 群发短信
*/
public class Phone {
​
  // 成员变量
  String brand; // 品牌
  double price; // 价格
  String color; // 颜色
​
  // 成员方法
  public void call(String who) {
      System.out.println("给" + who + "打电话");
  }
​
  public void sendMessage() {
      System.out.println("群发短信");
  }
}

局部变量和成员变量

1. 定义的位置不一样【重点】 局部变量：在方法的内部 成员变量：在方法的外部，直接写在类当中

2. 作用范围不一样【重点】 局部变量：只有方法当中才可以使用，出了方法就不能再用 成员变量：整个类全都可以通用。

3. 默认值不一样【重点】 局部变量：没有默认值，如果要想使用，必须手动进行赋值 成员变量：如果没有赋值，会有默认值，规则和数组一样

4. 内存的位置不一样（了解） 局部变量：位于栈内存 成员变量：位于堆内存

5. 生命周期不一样（了解） 局部变量：随着方法进栈而诞生，随着方法出栈而消失 成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

 

package cn.itcast.day06.demo03;
public class Demo01VariableDifference {
​
  String name; // 成员变量
​
  public void methodA() {
      int num = 20; // 局部变量
      System.out.println(num);
      System.out.println(name);
  }
​
  public void methodB(int param) { // 方法的参数就是局部变量
      // 参数在方法调用的时候，必然会被赋值的。
      System.out.println(param);
​
      int age; // 局部变量
//       System.out.println(age); // 没赋值不能用
​
//       System.out.println(num); // 错误写法！
      System.out.println(name);
  }
​
}
​

封装性

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

封装性在Java当中的体现：

1. 方法就是一种封装

2. 关键字private也是一种封装

封装就是将一些细节信息隐藏起来，对于外界不可见。

package cn.itcast.day06.demo03;
public class Demo02Method {
​
  public static void main(String[] args) {
      int[] array = {5, 15, 25, 20, 100};
​
      int max = getMax(array);
      System.out.println("最大值：" + max);
  }
​
  // 给我一个数组，我还给你一个最大值
  public static int getMax(int[] array) {
      int max = array[0];
      for (int i = 1; i < array.length; i++) {
          if (array[i] > max) {
              max = array[i];
          }
      }
      return max;
  }
​
}

private关键字

问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。 解决方案：用private关键字将需要保护的成员变量进行修饰。

一旦使用了private进行修饰，那么本类当中仍然可以随意访问。 但是！超出了本类范围之外就不能再直接访问了。

定义Getter/Setter

间接访问private成员变量，就是定义一对儿Getter/Setter方法

必须叫setXxx或者是getXxx命名规则。 对于Getter来说，不能有参数，返回值类型和成员变量对应； 对于Setter来说，不能有返回值，参数类型和成员变量对应。

package cn.itcast.day06.demo03;
public class Person {
​
  String name; // 姓名
  private int age; // 年龄
​
  public void show() {
      System.out.println("我叫：" + name + "，年龄：" + age);
  }
​
  // 这个成员方法，专门用于向age设置数据
  public void setAge(int num) {
      if (num < 100 && num >= 9) { // 如果是合理情况
          age = num;
      } else {
          System.out.println("数据不合理！");
      }
  }
​
  // 这个成员方法，专门私语获取age的数据
  public int getAge() {
      return age;
  }
​
}

package cn.itcast.day06.demo03;
​
public class Demo03Person {
​
  public static void main(String[] args) {
      Person person = new Person();
      person.show();
​
      person.name = "赵丽颖";
//       person.age = -20; // 直接访问private内容，错误写法！
      person.setAge(20);
      person.show();
  }
​
}

package cn.itcast.day06.demo03;
​
/*
对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
*/
public class Student {
​
  private String name; // 姓名
  private int age; // 年龄
  private boolean male; // 是不是爷们儿
​
  public void setMale(boolean b) {
      male = b;
  }
​
  public boolean isMale() {
      return male;
  }
​
  public void setName(String str) {
      name = str;
  }
​
  public String getName() {
      return name;
  }
​
  public void setAge(int num) {
      age = num;
  }
​
  public int getAge() {
      return age;
  }
}

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。 格式： public 类名称(参数类型 参数名称) { 方法体 }

注意事项：

1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样

2. 构造方法不要写返回值类型，连void都不写

3. 构造方法不能return一个具体的返回值

4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。 public Student() {}

5. 一旦编写了至少一个构造方法，那么编译器将不再赠送。

6. 构造方法也是可以进行重载的。 重载：方法名称相同，参数列表不同。

package cn.itcast.day06.demo04;
public class Student {
​
  // 成员变量
  private String name;
  private int age;
​
  // 无参数的构造方法
  public Student() {
      System.out.println("无参构造方法执行啦！");
  }
​
  // 全参数的构造方法
  public Student(String name, int age) {
      System.out.println("全参构造方法执行啦！");
      this.name = name;
      this.age = age;
  }
​
  // Getter Setter
  public void setName(String name) {
      this.name = name;
  }
​
  public String getName() {
      return name;
  }
​
  public void setAge(int age) {
      this.age = age;
  }
​
  public int getAge() {
      return age;
  }
​
}

package cn.itcast.day06.demo04;
​
public class Demo02Student {
​
  public static void main(String[] args) {
      Student stu1 = new Student(); // 无参构造
      System.out.println("============");
​
      Student stu2 = new Student("赵丽颖", 20); // 全参构造
      System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
      // 如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
      stu2.setAge(21); // 改变年龄
      System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
​
  }
​
}

this.成员变量名

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。 如果需要访问本类当中的成员变量，需要使用格式： this.成员变量名

“通过谁调用的方法，谁就是this。”

package cn.itcast.day06.demo04;
​
​
public class Person {
​
  String name; // 我自己的名字
​
  // 参数name是对方的名字
  // 成员变量name是自己的名字
  public void sayHello(String name) {
      System.out.println(name + "，你好。我是" + this.name);
      System.out.println(this);
  }
​
}

package cn.itcast.day06.demo04;
​
public class Demo01Person {
​
  public static void main(String[] args) {
      Person person = new Person();
      // 设置我自己的名字
      person.name = "王健林";
      person.sayHello("王思聪");
​
      System.out.println(person); // 地址值
  }
​
}

标准的类

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

1. 所有的成员变量都要使用private关键字修饰

2. 为每一个成员变量编写一对儿Getter/Setter方法

3. 编写一个无参数的构造方法

4. 编写一个全参数的构造方法

这样标准的类也叫做Java Bean

package cn.itcast.day06.demo05;
public class Student {
​
  private String name; // 姓名
  private int age; // 年龄
​
  public Student() {
  }
​
  public Student(String name, int age) {
      this.name = name;
      this.age = age;
  }
​
  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 cn.itcast.day06.demo05;
​
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("古力娜扎", 21);
      System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
      stu2.setAge(22);
      System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
  }
​
}