Java编程基础阶段笔记day07面向对象编程（上）-创新互联

面向对象编程

笔记Notes

• 面向对象三条学习主线

• 面向过程 VS 面向对象

• 类和对象

• 创建对象例子

• 面向对象的内存分析

• 类的属性：成员变量

• 成员变量 VS 局部变量

• 类的方法

• 方法的重载

• 可变个数形参

• 面向对象：封装性

• 访问权限修饰符

• 构造方法（构造器）

• 给属性赋值的方法

• UML类图

• this 关键字

• 面向对象学习主线

  • 类及类的成员：属性，方法，构造器，代码块，内部类

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

  • 其他关键字：this,super,interface,final,static......

• 面向过程 vs 面向对象

  • 面向过程：强调的是功能行为

  • 面向对象 ：强调具备了功能的对象               

• 类和对象的区别

  • 类：抽象的（汽车设计模板）

  • 对象：具体的，类的实例（根据模板造出的汽车）

• 类的成员：属性和方法

  • 属性 = field = 成员变量

  • （成员）方法 = 函数 = method

• 面向对象的例子

1.创建一个类，并在类中提供必要的属性和方法

2.由类派生出对象。（创建对象）

3.调用对象中的属性和方法。（对象名.属性名/方法名）

         //创建一个类

class Person{

//属性

String name;

int age;

char sex;

//方法

public void run(){

  System.out.println(name + "跑起来");

}

public void say(){

  System.out.println(name + "今年" + age);

}

}

// main 方法中

  Person person = new Person();

  //调用属性 ：对象名.属性名

  person.name = "王庆港"; //给属性赋值

  person.age = 23;

  //获取属性的值

  String name = person.name;

  System.out.println("name=" + name);

  //调用方法 ：对象名.方法名

  person.run();

  person.say();

• 面向对象的内存分析

  • 同一个类创建的多个对象，每个对象独自拥有一份属性。

  • 当修改其中一个对象的属性的值后，其它对象的该属性不会受到影响

• 类的成员之 ：属性（成员变量）

• • 变量的分类：

①按照数据类型分 ：基本数据类型 vs 引用数据类型

②按照位置分 ：成员变量  vs 局部变量

• 成员变量和局部变量  相同点：

①变量的声明的格式都是一样的。

②变量都有作用域

③变量都是先声明后使用

• • 成员变量和局部变量 不同点：

①局部变量：在方法里，方法的形参，构造器中，构造器的形参，代码块

②成员变量： 在类中方法等结构外

• • 权限修饰符：

①局部变量：不能使用权限修饰符修饰

②成员变量：可以使用四种权限修饰符（public protected 缺省的(default) private）

• • 内存：

①局部变量：在内存的栈中

②成员变量：在内存的堆（对象）中

• • 默认值：

①局部变量 ：没有默认值

②成员变量 ：有默认值（和数组元素的默认值是一样的）

byte,short,int,long -> 0

float,double -> 0.0

boolean -> false

char -> \u0000

引用数据类型 -> null

class Animal{

//属性（成员变量）

public String name = "动物";

int legs;

protected boolean isLive = true;

{//代码块

  String address = "";//局部变量

}

public Animal(){} 

//构造器

public Animal(int sex){//构造器的形参

  int a = 10;//局部变量

}

//方法

public void say(int sex){//方法的形参

  //局部变量

  int age = 10;

  age = 20;

  name = "大锤";

}

}

• • 不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。

  • 如：new Person().shout();

• 类的成员：方法（method）

  • Java里的方法不能独立存在，所有的方法必须定义在类里。

  • 方法的声明格式：

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛

方法体程序代码

return 返回值;

}

• • 权限修饰符 ：public protected 缺省的  private (先用public)

①void/具体的类型（基本数据类型、引用数据类型）：

②void : 表示该方法没有返回值

具体的类型 ：调用该方法会有返回值。

注意：返回数据需要使用return关键字。return 后面跟需要返回的数据。

• • 方法名 ：只需要遵守标识符的规则和规范即可

(形参相同的情况下，同一个类中的方法名不能相同)。

• • 形参列表 ：可以有0个1个或多个。多个之间使用","隔开。

①作用 ：用来通知方法的调用者调用此方法时需要传递数据。

②注意：实参的类型必须和形参的类型保持一致

• • 方法体 ：方法功能的具体体现。

注意 ：只有调用方法时方法体才会执行。

对象数组题目：

定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。

问题一：打印出3年级(state值为3）的学生信息。

问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：

1) 生成随机数：Math.random()，返回值类型double; 

2) 四舍五入取整：Math.round(double d)，返回值类型long。

class Student1{

int  number;

int state;

int score;

@Override

public String toString() {

  return "Student1 [number=" + number + ", state=" + state + ", score=" + score + "]";

}

}

public class StuInfo {

public static void main(String[] args) {

  // 创建对象数组

  Student1[] studentArr = new Student1[20];

  // 循环创建对象并赋值，传给对象

  for (int i = 0; i < 20; i++) {

            Student1 student1 = new Student1();

            student1.number = i;

            student1.state = (int)Math.round( (Math.random()*7));

            student1.score = (int) (Math.random()*100);   

            studentArr[i] = student1;

  }

  System.out.println("---------打印排序前的学生信息-------------");

  for (int i = 0; i < studentArr.length; i++) {

            System.out.println(studentArr[i]);

  }

  System.out.println("----------打印state为3的学生信息---------");

  // 循环查找对象数组中state值为3的对象，打印输出对象信息

  for (int i = 0; i < studentArr.length; i++) {

            if (studentArr[i].state == 3) {

                     System.out.println(studentArr[i]);

            }

  }

  System.out.println("----------------------------------------");

  // 使用冒泡排序按学生成绩排序，并遍历所有学生信息

  // 思路：两个循环遍历数组中的对象的成绩，若对象的成绩小于后一个，则交换对象的位置

  for (int i = 0; i < studentArr.length -1; i++) { // 外层循环决定冒泡排序的次数，为数组长度-1

            for (int j = 0; j < studentArr.length - i -1; j++) { // 内层循环决定每次多少次冒泡，为

                     if (studentArr[j].score > studentArr[j+1].score) { // 如果前面的对象小于大于后面的，就叫交换类数组地址

                               Student1 temp = studentArr[j];

                               studentArr[j] = studentArr[j+1];

                               studentArr[j+1] = temp;

                     }

            }

  }

  // 注意！！！！！！！！！！

  // 冒泡排序交换的值的数组的下标为内循环的循环变量

  System.out.println("------打印排序后的信息-------");

  // 打印排序后的信息

  for (int i = 0; i < studentArr.length; i++) {

            System.out.println(studentArr[i]);

  }

}

}

• 重载的概念、特点、实例

①在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

②与返回值类型无关，只看参数列表，且参数列表必须不同。

(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

③示例：

//返回两个整数的和

int add(int x,int y){return x+y;}

//返回三个整数的和

int add(int x,int y,int z){return x+y+z;}

//返回两个小数的和

double add(double x,double y){return x+y;}

注意！！：

①不同的形参列表 ：形参的个数，顺序，类型不同

②方法的重载和权限修饰符，返回值类型，形参的名字无关。

③判断方法:只看 方法名　＋ 形参列表（看形参和实参的类型）

• 可变个数形参

  • 格式 ：变量的类型 ... 变量名

  • 说明：

             ①可变形参的底层就是一个数组

             ②在可变形参的方法中，和可变形参相同类型的数组的方法不构成重载。

             ③在形参列表中可变形参只能放在最后

             ④在同一个方法的形参列表中只能有一个可变形参。

             ⑤ 可变形参的个数可以是0个1个或多个

• 方法的参数传递

  • 基本数据类型的参数传递

  • 引用数据类型的参数传递

  • 方法的参数传递

• 面向对象：封装

  • 为什么要使用封装性？

在创建对象以后，就可以通过对象名.属性名这种方式对属性直接进行操作。这种操作对于属性只有类型和范围的限制。但是在实际开发中我们会有更多的其它的限制条件。而这些限制条件又不能在属性的声明处加以限制。我们采取取如下方式

①使用权限修饰符对属性进行权限的限制，那么在类的外部就不能随意的再调用类中的属性

②提供公共的方法，在方法中可以加以限制其它的条件。然后可以通过该方法给属性赋值和获取属性的值。

• 封装性的体现（狭义上）：

①将属性私有化。（private修饰属性）

②提供公共的set/get方法。（set方法用来给属性赋值，get方法用来获取属性的值）

• 封装性的体现（广义上）：

①可以使用四种权限修饰符:private,缺省的，protected,public

②四种权限修饰符可以修饰 ：属性，方法，构造器，内部类

③类只能被public和缺省的修饰。

• 四种访问权限修饰符

• 构造方法（构造器）

  • 构造器的特征

    • 它具有与类相同的名称

    • 它不声明返回值类型。（与声明为void不同）

    • 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

  • 构造器的作用：创建对象；给对象进行初始化

    • 如：Order o = new Order();    Person p = new Person(“Peter”,15);

  • 根据参数不同，构造器可以分为如下两类：

    • 隐式无参构造器（系统默认提供）

    • 显式定义一个或多个构造器（无参、有参）

  • 注  意：

    • Java语言中，每个类都至少有一个构造器

    • 默认构造器的修饰符与所属类的修饰符一致

    • 一旦显式定义了构造器，则系统不再提供默认构造器

    • 一个类可以创建多个重载的构造器

    • 父类的构造器不可被子类继承

  • 构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。

• 给属性赋值的方法

  • 赋值的位置：

① 默认初始化：int a;

② 显式初始化：int a = 0;

③ 构造器中初始化

④ 通过“对象.属性“或“对象.方法”的方式赋值

• • 赋值的先后顺序：

① - ② - ③ - ④

• JavaBean：Java语言编写的可重用组件

  • 定义：是一个普通的Java类，但是符合如下标准

  • ①类是公共的

  • ②有一个无参的公共的构造器

  • ③有属性，且有对应的get、set方法

• UML类图

• • ①+ 表示 public 类型， - 表示 private 类型，#表示protected类型

  • ②方法的写法：方法的类型(+、-)  方法名(参数名：参数类型)：返回值类型

• this 关键字

  • this 是什么？

①它在方法内部使用，即这个方法所属对象的引用；

②它在构造器内部使用，表示该构造器正在初始化的对象。

• this作用域：this 可以调用类的属性、方法和构造器

• 适用情形：当在方法内需要用到调用该方法的对象时，就用this。

具体的：我们可以用this来区分属性和局部变量。

public void setAge(int age){

age = age;//局部变量 ：就近原则（属性名和局部变量名相同时默认调用的是局部变量）

       System.out.println("===========" + age);

}

• this 调用构造器

总结Summary

• 面向对象的内存分析

• 成员变量与局部变量

• 构造器

• 函数重载