Java 进阶知识篇 面向对象与封装

案例展示

面向过程：强调 步骤
面向对象：强调 对象

• 面向过程，当实现一个功能时候，考虑每一个步骤
• 面向对象，当实现一个功能时候，不关心具体步骤，只关心调用谁能实现，如下案例：

import java.lang.reflect.Array;
 import java.util.Arrays;

public class demo1 {
 public static void main(String[] args) {
  int[] array = {10, 20, 30, 40, 50};
  System.out.println(Arrays.toString(array));
 }
}

面向对象思想

一、面向对象语言有三大特征：

1. 封装
2. 继承
3. 多态

二、类和对象

2.1 什么是类

• 类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类。
• 属性：事物的状态信息（成员变量）
• 行为：事物的能力（成员方法）

2.2 什么是对象

• 对象：是一类事物的具体体现，对象是类的一个实例，具备该类事物的属性和行为。

2.3 类与对象的关系

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

类是对象的模板，对象是类的实体

2.4 类的定义

两点注意：

1. 成员变量定义与类当中，成员方法外部。
2. 成员方法没有 static 关键字（静态的）

public class demo2 {

 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("学习");
  }

 }

}

2.5 对象的创建及使用

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

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

import 包名称.类名称;

对于和当前属于同一个类的情况，可以省略导包语句
2. 创建

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

student stu = new student;
3. 使用：用谁 “.” 谁
使用成员变量：

对象名.成员变量名

使用成员方法：

对象名.成员方法名（参数）

案例：

package Day1;

import Day1.demo2;

public class demo3 {
 public static void main(String[] args) {
  demo2.Student stu = new demo2.Student();
  System.out.println(stu.age);
  System.out.println(stu.name);
  System.out.println("==========");
  //需要赋值
  stu.name = "郭照凯";
  stu.age = 22;
  System.out.println(stu.age);
  System.out.println(stu.name);
  System.out.println("==========");
  //使用方法
  stu.eat();
 }
}

结果：

2.6 使用对象类型作为方法的参数

因为任何数据类型都可以作为参数，所以对象类型也可以作为方法的参。
当一个对象作为参数，传递到方法当中时，实际上传递的是对象的地址值。

package Day1;

public class demo2PhoneParam {
 public static void main(String[] args) {
  demo2Phone phone = new demo2Phone();
  phone.brand = "苹果";
  phone.color = "red";
  phone.price = 5000.0;

  method(phone);//传递进去的参数其实就是地址值
 }

 public static void method(demo2Phone param) {
  System.out.println(param.brand);
  System.out.println(param.price);
  System.out.println(param.color);
 }
}

2.7使用对象类型作为方法的返回值

package Day1;

public class demo2PhoneReturn {
 public static void main(String[] args) {
  demo2Phone receivePhone = getmethod();//类新建一个对象去接收getmethod()的返回值
  System.out.println(receivePhone.brand);
  System.out.println(receivePhone.price);
  System.out.println(receivePhone.color);
 }

 public static demo2Phone getmethod() {
  demo2Phone phone = new demo2Phone();
  phone.brand = "三星";
  phone.price = 5222.0;
  phone.color = "red";
  return phone;
 }
}

2.8对象的内存图

一个对象与两个对象使用一个方法的内存其引用方式和结构类型相差不大。
方法区存东西
方法区运行需要进栈（压栈：进栈之后放在栈的最下方）
new 的东西在堆中
成员方法中储存的其实是地址值，指向方法区

当一个对象作为参数，传递到方法当中时候，实际上传递进去的是对象的地址值。
当一个对象作为返回值时，返回值就是对象的地址值。

2. 9成员变量和局部变量区别

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

package Day1;

public class demo4 {

 String name;//成员变量

 public void methodA() {

  int num = 20;//局部变量

 }
 
}

2. 作用范围不一样
   局部变量：只有方法中才可使用，方法外失效
   成员变量：整个类中全部可以使用

package Day1;

public class demo4 {

 String name;//成员变量

 public void methodA() {
  int num = 20;//局部变量
  System.out.println(num);
  System.out.println(name);//成员变量在methodA中可以被引用
 }

 public void methodB(){
//  System.out.println(num); //错误写法，methodA中局部变量在methodB中输出报错
  System.out.println(name);//成员变量在methodB中可以被引用
 }
}

3. 默认值不一样
   局部变量：没有默认值，使用需要手动赋值
   成员变量：有默认值，规则和数组一样

package Day1;

public class demo4 {

 String name;//成员变量

 public void methodA() {
  int num = 20;//局部变量
  System.out.println(num);
  System.out.println(name);//成员变量在methodA中可以被引用
 }

 public void methodB() {
  int age;
//  System.out.println(age);//错误写法，age没有赋值
//  System.out.println(num); //错误写法，methodA中局部变量在methodB中输出报错
  System.out.println(name);//成员变量在methodB中可以被引用
 }

 public void methodC(int param) {//方法参数是局部变量
  System.out.println(param);
//  此处不报错的原因是因为，参数在方法调用时候，必然被赋值
 }

}

若局部变量没有赋值，在使用时候会爆出如下错误；

三、封装性

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

体现有两点：

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

3.1 方法封装举例：

package Day1;

 import java.util.Arrays;

public class demo5 {
 public static void main(String[] args) {
  int[] array = {10, 20, 30, 50, 60, 100, 90};
  int max = getMax(array);
  System.out.println(Arrays.toString(array));
  System.out.println("最大值:"+ max);
 }

 //把步骤封装成方法，只管调用
 public static int getMax(int[] array) {
  int max = array[0];
  for (int i = 0; i < array.length; i++) {
   if (array[i] > max) {
    max = array[i];
   }
  }
  return max;
 }
}

3.2 private封装

用private关键字将需要保护的成员变量进行修饰使其私有化。
一旦使用了private修饰，只能在本类中使用，超出本类需要使用get、set方法

间接访问private成员变量，就是定义一对getter和setter方法

getXxx和setXxx命名规则：

• 对于getXxx，不能有参数，返回值类型和成员变量相对应。
• 对于setXxx，不能有返回值，参数类型和成员变量相对应。
• 基本类型中 布尔值 的get方法要写 isXxx

定义一个标准类

1. 成员变量用private定义
2. 每一个成员变量都需要一对二getter和setter方法
3. 编写一个无参数的构造方法
4. 编写一个有参数的构造方法

package Day1;

public class preson {
 private String name;
 private int age;
 private boolean male;

 public preson() {
 }

 public preson(String name, int age, boolean male) {
  this.name = name;
  this.age = age;
  this.male = male;
 }

 public void show() {
  System.out.println("姓名:" + name + "  " + "年龄:" + age + "  " + "是不是爷们:" + male);
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  if (age > 150 && age < 0) {
   System.out.println("数据不合理");
  } else {
   this.age = age;
  }
 }

 public boolean isMale() {//基本类型中布尔值的get方法要写isXxx
  return male;
 }

 public void setMale(boolean male) {
  this.male = male;
 }
}

package Day1;

public class demo6Preson {
 public static void main(String[] args) {
  preson preson = new preson();
  preson.setName("郭照凯");
  preson.setAge(19);
  preson.setMale(true);
  preson.show();
 }
}

结果：