前言

学习面向对象内容的三条主线

  1. Java类及类的成员 （属性、方法、构造器；代码块、内部类）
  2. 面向对象的三大特征 （封装、继承、多态）
  3. 其它关键字

一、面向过程与面向对象

1.1 面向过程（POP）与面向对象（OOP）

  • 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
  • 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

1.2 面向对象的三个特征

  • 封装
  • 继承
  • 多态

1.3 面向对象的思想概述

  • 程序员从面向过程的执行者转化成了面向对象的指挥者

  • 面向对象分析方法分析问题的思路和步骤：

    • 根据问题需要，选择问题所针对的现实世界中的实体。
    • 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
    • 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
    • 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

1.4 案例

人把大象装进冰箱

1.（对象、属性、方法） - 图1

  1. 一、Java面向对象学习的三条主线：（第4-6章）
  2. 1.Java类及类的成员：属性、方法、构造器；代码块、内部类
  3. 2.面向对象的三大特征：封装性、继承性、多态性（抽象性）
  4. 3.其它关键字：this、super、static、final、abstract、interface、package、import等
  6. *二、“人把大象装进冰箱”
  7. *1.面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做
  8. *
  9. *①把冰箱门打开
  10. *②抬起大象，装进冰箱
  11. *③把冰箱门关闭
  12. *
  13. *2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
  14. *
  15. *人{
  16. *    打开(冰箱){
  17. *        冰箱.开开();
  18. *    } 
  19. *
  20. *    抬起(大象){
  21. *        大象.进入(冰箱);
  22. *    }
  23. *
  24. *    关闭(冰箱){
  25. *        冰箱.闭合();
  26. *    }
  27. *}
  28. *
  29. *冰箱{
  30. *    开开(){}
  31. *    闭合(){}
  32. *}
  33. *
  34. *大象{
  35. *    进入(冰箱){
  36. *    }
  37. *}

二、Java语言的基本元素：类和对象

2.1 面向对象的思想概述

  • 类：类是对一类事物的描述，是抽象的、概念上的定义
  • 对象：对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
  1. 可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人；
  2. 面向对象程序设计的重点是类的设计
  3. 设计类：其实就是设计类的成员

2.2 Java类及类的成员

  • 现实世界的生物体，大到鲸鱼，小到蚂蚁，都是由最基本的细胞构成的。同理，Java代码世界是由诸多个不同功能的类构成的。

  • 现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么， Java中用类class来描述事物也是如此。常见的类的成员有：

    • 属性：对应类中的成员变量
    • 行为：对应类中的成员方法

1.（对象、属性、方法） - 图2

2.3 类的语法格式

  1. 修饰符 class 类名 {
  2.    属性声明;
  3.    方法声明; 
  4. }
  5. //说明：修饰符public：类可以被任意访问,类的正文要用{ }括起来

比如：

  1. public class Person{
  2.     private int age ; //声明私有变量 age
  3.     public void showAge(int i) { //声明方法showAge( )
  4.         age = i; 
  5.     } 
  6. }

2.4 创建Java自定义类

  • 步骤：

    1. 定义类（考虑修饰符、类名）
    2. 编写类的属性（考虑修饰符、属性类型、属性名、初始化值）
    3. 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

三、对象的创建和使用

  • 创建对象语法： 类名 对象名 = new 类名();
  • 使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）
  1. public class Animal {
  2.     public int legs;
  3.     public void eat(){
  4.         System.out.println(“Eating.”);
  5.     }
  6.     public viod move(){
  7.         System.out.println(“Move.”);
  8.     }
  9. }

比如：

  1. public class Zoo{
  2.     public static void main(String args[]){
  3.     //创建对象
  4.     Animal xb=new Animal();
  5.     xb.legs=4;//访问属性
  6.     System.out.println(xb.legs);
  7.     xb.eat();//访问方法
  8.     xb.move();//访问方法
  9.     } 
  10. }

3.1 提 示

  • 类的访问机制：

    • 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static，编译不通过。）
    • 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

3.2 对象的产生

Person p1 = new Person();执行完后的内存状态。其中类定义如下：

  1. class Person{
  2.     int age;
  3.     void shout(){
  4.         System.out.println(“oh,my god! I am ” + age);
  5.     } 
  6. }

1.（对象、属性、方法） - 图3

3.3 对象的使用

  1. class PersonTest{
  2.     public static void main(String[] args) { //程序运行的内存布局如下图
  3.         Person p1 = new Person();
  4.         Person p2 =new Person();
  5.         p1.age = -30;
  6.         p1.shout();
  7.         p2.shout();
  8.     } 
  9. }

1.（对象、属性、方法） - 图4

3.3 对象的生命周期

1.（对象、属性、方法） - 图5

3.4 对象的内存解析

  • 堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在
    Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

  • 通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、 char 、 short 、 int 、 float 、 long 、 double）、对象引用（reference类型， 它不等同于对象本身，是对象在堆内存的首地址）。 方法执行完，自动释放。

  • 方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

局部变量在栈空间中，属性（成员变量）在堆空间中

1.（对象、属性、方法） - 图6

3.4.1 案例1

  1. package com.atguigu.java;
  3. /*
  4.  * 一、设计类，就是设计类的成员
  5.  *     属性 = 成员变量 = field = 域、字段
  6.  *     方法 = 成员方法 = 函数 = method
  7.  * 
  8.  *     创建类的对象 = 类的实例化 = 实例化类
  9.  * 
  10.  * 二、类和对象的使用（面向对象思想落地的实现）
  11.  *     1.创建类、设计类的成员（属性、方法）
  12.  *     2.创建类的对象（类的实例化）
  13.  *     3.通过“对象.属性”或“对象.方法”调用对象的结构
  14.  * 
  15.  * 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
  16.  *         意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值
  17.  * */
  19. //测试类
  20. public class PersonTest {
  21.     public static void main(String[] args){
  22.         //2.创建Person类的对象
  23.         Person p1 = new Person();//类的实例化
  24.         //Scanner scanner = new Scanner(System.in);
  26.         //调用对象的结构：属性、方法
  27.         //调用属性：“对象.属性”
  28.         p1.name = "Tom";
  29.         p1.isMale = true;
  30.         System.out.println(p1.name);
  32.         //调用方法：“对象.方法”
  33.         p1.eat();
  34.         p1.sleep();
  35.         p1.talk("chinese");
  37.         //*************************
  38.         Person p2 = new Person();//开辟空间
  39.         System.out.println(p2.name);//null
  40.         System.out.println(p2.isMale);//false
  42.         //*************************
  43.         //p1变量保存的对象地址值赋给p3,导致p1和p3指向堆空间的同一个对象实体
  44.         Person p3 = p1;//相当于p1的快捷方式
  45.         System.out.println(p3.name);//Tom
  47.         p3.age = 10;
  48.         System.out.println(p1.age);//10
  49.     }
  50. }
  52. //1.创建类、设计类的成员（属性、方法）
  53. class Person{
  54.     //属性
  55.     String name;//引用类型,默认为null
  56.     int age = 1;
  57.     boolean isMale;//默认为false
  59.     //方法
  60.     public void eat(){
  61.         System.out.println("人可以吃饭");
  62.     }
  64.     public void sleep(){
  65.         System.out.println("人可以睡觉");
  66.     }
  68.     public void talk(String language){
  69.         System.out.println("人可以说话，使用的是：" + language);//连接符
  70.     }
  71. }

1.（对象、属性、方法） - 图7

3.4.2 案例2

1.（对象、属性、方法） - 图8

3.5 匿名对象

  1. package com.atguigu.java;
  2. /*
  3.  * 一、理解”万事万物皆对象“
  4.  * 1.在jav语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
  5.  *     >Scanner,String等
  6.  *     >文件：File
  7.  *     >网络资源：URL
  8.  * 2.涉及到Java语言与前端Html、后端数据库交互时，前后端的结构在Java层面交互时,都体现为类、对象
  9.  * 
  10.  * 二、内存解析的说明
  11.  * 1.引用类型的变量，只可能存储两类值：null 或 地址值(包含变量的类型)
  12.  * 
  13.  * 三、匿名对象的使用
  14.  * 1.理解：我们创建的对象，没有显示的赋给一个变量名，即为匿名对象
  15.  * 2.特征：匿名对象只能调用一次
  16.  * 3.使用
  17.  */
  18. public class InstanceTest {
  19.     public static void main(String[] args) {
  21.         Phone p = new Phone();
  22.         System.out.println(p);//地址值
  24.         p.sendEmail();
  25.         p.play();
  27.         //匿名对象
  28.         /*new Phone().sendEmail();
  29.         new Phone().play();*/
  31.         new Phone().price = 1999;
  32.         new Phone().showPrice();//0.0
  34.         //****************************
  35.         PhoneMall mall = new PhoneMall();
  36. //        mall.show(p);
  37.         //匿名对象的使用
  38.         mall.show(new Phone());//实参的值传递给形参
  40.     }    
  41. }
  43. class PhoneMall{
  45.     public void show(Phone phone){
  46.         phone.sendEmail();
  47.         phone.play();
  48.     }
  50. }
  52. class Phone{
  53.     double price;
  55.     public void sendEmail(){
  56.         System.out.println("发送邮件");
  57.     }
  59.     public void play(){
  60.         System.out.println("玩游戏");
  61.     }
  63.     public void showPrice(){
  64.         System.out.println("价格" + price);
  65.     }
  66. }

四、类的成员之一：属性(field)

  1. package com.atguigu.java;
  3. /*
  4.  * 类中属性的使用
  5.  * 
  6.  * 属性（成员变量）    VS    局部变量
  7.  * 1.相同点
  8.  *     1.1 定义变量的格式： 数据类型 变量名 = 变量值
  9.  *     1.2先声明,后使用
  10.  *     1.3变量都有其对应的作用域
  11.  * 
  12.  * 2.不同点：
  13.  *     2.1 在类中声明的位置不同
  14.  *         属性：直接定义在类的一对{}内
  15.  *         局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
  16.  *     
  17.  *     2.2关于权限修饰符的不同
  18.  *     属性：可以在声明属性时，指明其权限，使用权限修饰符。
  19.  *          常用的权限修饰符：private、public、缺省、protected--->封装性
  20.  *    局部变量：不可以使用权限修饰符。
  21.  *
  22.  *    2.3 默认初始化值的情况
  23.  *    属性：类的属性，根据其类型都有默认初始化值
  24.  *        整型（byte、short、int、long）：0
  25.  *        浮点型（float、double）：0.0
  26.  *        字符串（char）： 0（或'\u0000'）
  27.  *        布尔型：（boolean）：false
  28.  *
  29.  *        引用数据类型（类、数组、接口）：null
  30.  *
  31.  *    局部变量：没有默认初始化值
  32.  *        意味着：我们在调用局部变量之前，一定要显示赋值
  33.  *        特别地：形参在调用时，我们赋值即可
  34.  *    2.4 在内存中加载的位置
  35.  *    属性：加载到堆空间中（非static）
  36.  *    局部变量：加载到栈空间
  37.  * 
  38.  * */
  40. public class UserTest {
  41.     public static void main(){
  42.         User u1 = new User();
  43.         System.out.println(u1.name);
  44.         System.out.println(u1.age);
  45.         System.out.println(u1.isMale);
  47.         u1.talk("日语");
  48.     }
  49. }
  51. class User{
  52.     //属性（或成员变量）
  53.     String name;
  54.     int age;
  55.     boolean isMale;
  57.     public void talk(String language){//;/language:形参
  58.         System.out.println("我们使用" + language + "进行交流");
  60.     }
  62.     public void eat(){
  63.         String food = "烙饼";//局部变量
  64.         System.out.println("北方人喜欢吃： " + food);
  65.     }
  66. }

五、类的成员之二： 方法(method)

  1. package com.atguigu.java;
  3. /*
  4.  * 类中方法的声明和使用
  5.  * 
  6.  * 方法：描述类应该具有的功能
  7.  *比如：Math类：sqrt()\randow()\...
  8.  *        Scanner类：nextXxx()...
  9.  *        Arrays类：sort()\binarySearch()\toString()\equals()
  10.  *1.举例：
  11.  *public void eat(){}
  12.  *public void sleep(int hour){}
  13.  *public String getName(){}
  14.  *public String getNation(String nation){}
  15.  *
  16.  *2.方法的声明：权限修饰符 返回值类型 方法名(形参列表){
  17.  *                方法体
  18.  *}
  19.  *注意：static、final、abstract 来修饰的方法，后面再讲
  20.  *
  21.  *3. 说明：
  22.  *    3.1关于权限修饰符：
  23.  *        Java规定的四种权限修饰符：private、public、缺省、protected-->封装性细说
  24.  *    3.2返回值类型：有返回值 VS 没有返回值
  25.  *        3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字
  26.  *            来返回指定类型的变量或常量
  27.  *            如果方法没有返回值，则方法声明时，使用void来表示，通常没有返回值的方法中就不使用return
  28.  *            但是使用的话，只能“return;”表示结束此方法的意思
  29.  *
  30.  *        3.2.2我们定义方法时该不该有返回值？
  31.  *            ①题目要求
  32.  *            ②经验：具体问题具体分析
  33.  *    3.3方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
  34.  *    3.4形参列表：方法可以声明0个，1个，或多个形参
  35.  *        3.4.1 格式：数据类型1 形参1,数据类型2 形参2
  36.  *        3.4.2 我们定义方法时，该不该定义形参？
  37.  *            ①题目要求
  38.  *            ②经验：具体问题具体分析
  39.  *    3.5方法功能的体现：
  40.  *    
  41.  *
  42.  *4.return关键字的使用：
  43.  *    1.使用范围：使用在方法体中
  44.  *    2.作用：①结束方法
  45.  *           ②针对于有返回值的方法，使用“return 数据”方法，返回所要的数据
  46.  *    注意点：return关键字后面不可以声明执行语句
  47.  *
  48.  *5.方法的使用中，可以调用当前类的属性或方法
  49.  *        特殊的：方法A中又调用了方法A:递归方法
  50.  *        方法中，不可以定义方法
  51.  */
  53. public class CustomerTest {
  54.     public static void main(String args){
  56.         Customer cust1 = new Customer();
  58.         cust1.eat();
  60.     }
  61. }
  62. class Customer{
  64.     //属性
  65.     String name;
  66.     int age;
  67.     boolean isMale;
  69.     //方法
  70.     public void eat(){
  71.         System.out.println("客户吃饭");
  72.     }
  74.     public void sleep(int hour){
  75.         System.out.println("休息了" + hour + "个小时");        
  76.     }
  78.     public String getName(){
  80.         if(age > 18){
  81.             return name;
  82.         }else{
  83.             return "Tom";
  84.         }
  85.     }
  87.     public String getNation(String nation){
  88.         String info = "我的国籍是：" + nation; 
  89.         reurn info;
  90.     }    
  91. }

练习1：

  1. package com.atguigu.exer;
  3. /*
  4.  * 要求：
  5.  * (1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，
  6.  * 输出字符串“studying”，调用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。
  7.  * (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
  8. */
  10. public class PersonTest {
  11.     public static void main(String[] args) {
  12.         Person p1 = new Person();
  14.         p1.name = "Tom";
  15.         p1.age = 18;
  16.         p1.sex = 1;
  18.         p1.study();
  20.         p1.showAge();//alt+左  进去
  22.         int newAge = p1.addAge(2);
  23.         System.out.println(p1.name + "的新年龄为：" + newAge);
  25.         System.out.println(p1.age);//20
  27.         //*********************************
  28.         Person p2 = new Person();
  29.         p2.showAge();//0
  30.         p2.addAge(10);
  31.         p2.showAge();//10
  32.     }
  33. }

Person类

  1. package com.atguigu.exer;
  3. public class Person {
  5.     String name;
  6.     int age;
  7.     /**
  8.      * sex:1表明是男性
  9.      * sex:0表明是女性
  10.      */
  11.     int sex;
  13.     public void study(){
  14.         System.out.println("studying");
  15.     }
  17.     public void showAge(){
  18.         System.out.println("age" + age);
  19.     }
  21.     public int addAge(int i){
  22.         age += i;
  23.         return age;
  24.     }
  25. }

练习2：利用面向对象的编程方法，设计类Circle计算圆的面积

CircleTest类

  1. package com.atguigu.exer;
  3. /*
  4.  * 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
  5.  * 
  6.  */
  7. //测试类
  8. public class CircleTest {
  9.     //程序的入口
  10.     public static void main(String[] args) {
  12.         Circle c1 = new Circle();
  14.         c1.radius = 2.1;
  16.         /*//对应方式一：
  17.         double area = c1.findArea();
  18.         System.out.println(area);*/
  20.         //对应方式二：
  21.         c1.findArea();
  22.     }
  24. }
  26. //圆
  27. class Circle{
  29.     //属性/成员变量
  30.     double radius;
  32.     //求圆的面积
  33.     //方式一：
  34.     /*public double findArea(){
  35.         double area = 3.14 * radius * radius;
  36.         return area;
  37.     }*/
  39.     //方式二：
  40.     public void findArea(){
  41.         double area = 3.14 * radius * radius;
  42.         System.out.println("面积为：" + area);
  43.     }    
  44. }

练习3

  1. package com.atguigu.exer;
  3. /*
  4.  * 3.1 编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形， 在main方法中调用该方法。 3.2 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再
  5.  * 计算该矩形的面积，并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
  6.  * 3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个
  7.  * m*n的*型矩形，并计算该矩形的面积， 将其作为方法返回值。在main方法
  8.  * 中调用该方法，接收返回的面积值并打印.
  9.  * */
  11. public class Exer3Test {
  13.     public static void main(String[] args) {
  14.         Exer3Test test = new Exer3Test();
  16.         //3.1测试
  17. //        test.method();
  19.         //3.2测试
  20.         /*int area = test.method();
  21.         System.out.println(area);*/
  23.         //3.3测试
  24.         int area = test.method(2,2);
  25.         System.out.println(area);
  27.     }
  29.     //3.1
  30.     /*public void method(){
  31.         for(int i = 0;i < 10;i++){
  32.             for(int j = 0;j < 8;j++){
  33.                 System.out.print("* ");
  34.             }
  35.             System.out.println();
  36.         }
  37.     }*/
  39.     //3.2
  40.     /*public int method(){
  41.         for(int i = 0;i < 10;i++){
  42.             for(int j = 0;j < 8;j++){
  43.                 System.out.print("* ");
  44.             }
  45.             System.out.println();
  46.         }
  47.         return 10 * 8;
  48.     }*/
  50.     //3.3
  51.     public int method(int m,int n){
  52.         for(int i = 0;i < m;i++){
  53.             for(int j = 0;j < n;j++){
  54.                 System.out.print("* ");
  55.             }
  56.             System.out.println();
  57.         }
  58.         return m * n;
  59.     }
  60. }

练习4

  1. package com.atguigu.exer;
  3. /*4. 对象数组题目：
  4. 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
  5.  创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
  6. 问题一：打印出3年级(state值为3）的学生信息。
  7. 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
  8. 提示：
  9. 1) 生成随机数：Math.random()，返回值类型double; 
  10. 2) 四舍五入取整：Math.round(double d)，返回值类型long。
  11. */
  12. public class StudentTest {
  14.     public static void main(String[] args) {
  16.         //声明Student类型的数组，String[] arr = new String[20];
  17.         Student[] stus = new Student[20];//动态
  19.         for(int i = 0;i < stus.length;i++){
  20.             //给数组元素赋值
  21.             stus[i] = new Student();
  22.             stus[i].number = i + 1;
  23.             //年级【1，6】
  24.             stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
  25.             //成绩：【0-100】
  26.             stus[i].score = (int)(Math.random() * (100 - 0 + 1) + 0); 
  27.         }
  29.         //遍历学生数组
  30.         for(int i = 0;i < stus.length;i++){
  31.             /*System.out.println(stus[i].number + "," + stus[i].state
  32.                     + "," + stus[i].score);*/
  33.             System.out.println(stus[i].info());
  34.         }
  36.         System.out.println("*************************");
  37.         //问题一：打印出3年级(state值为3）的学生信息。
  38.         for(int i = 0;i < stus.length;i++){
  39.             if(stus[i].state == 3){
  40.                 System.out.println(stus[i].info());
  41.             }    
  42.         }
  44.         System.out.println("*************************");
  46.         //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
  47.         for(int i = 0;i < stus.length - 1;i++){
  48.             //冒泡的比较次数就是比数组长度少一，所以减1
  49.             for(int j = 0; j < stus.length - i - 1;j++){
  50.                 if(stus[j].score > stus[j + 1].score){
  51.                     //如果需要换序，交换的是数组的元素，Student对象！！！
  52.                     Student temp = stus[j];
  53.                     stus[j] = stus[j + 1];
  54.                     stus[j + 1] = temp;
  55.                 }
  56.             }
  57.         }
  59.         //遍历学生数组
  60.         for(int i = 0;i < stus.length;i++){
  61.             System.out.println(stus[i].info());
  62.         }
  64.     }
  65. }
  67. class Student{
  68.     int number;//学号
  69.     int state;//年级
  70.     int score;//成绩
  72.     //显示学生信息的方法
  73.     public String info(){
  74.         return "学号：" + number + ",年级：" + state + ",成绩：" + score;
  75.     }
  76. }

练习5：对练习4的优化

  1. package com.atguigu.exer;
  3. /*4. 对象数组题目：
  4. 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
  5.  创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
  6. 问题一：打印出3年级(state值为3）的学生信息。
  7. 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
  8. 提示：
  9. 1) 生成随机数：Math.random()，返回值类型double; 
  10. 2) 四舍五入取整：Math.round(double d)，返回值类型long。
  12. 此代码是对StudentTest.java的改进：将操作数组的功能封装到方法中
  13. */
  14. public class StudentTest1 {
  16.     public static void main(String[] args) {
  18.         //声明Student类型的数组，String[] arr = new String[20];
  19.         Student1[] stus = new Student1[20];//动态
  21.         for(int i = 0;i < stus.length;i++){
  22.             //给数组元素赋值
  23.             stus[i] = new Student1();
  24.             stus[i].number = i + 1;
  25.             //年级【1，6】
  26.             stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
  27.             //成绩：【0-100】
  28.             stus[i].score = (int)(Math.random() * (100 - 0 + 1) + 0); 
  29.         }
  31.         StudentTest1 test = new StudentTest1();
  33.         //遍历学生数组
  34.         test.print(stus);
  36.         System.out.println("打印*************************");
  37.         //问题一：打印出3年级(state值为3）的学生信息。
  38.         test.searchState(stus, 3);
  40.         System.out.println("排序*************************");
  41.         //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
  42.         test.sort(stus);
  44.         //遍历学生数组
  45.         test.print(stus);
  46.     }
  48.     //遍历Student1[]数组的操作
  49.     public void print(Student1[] stus){
  50.         //遍历学生数组
  51.         for(int i = 0;i < stus.length;i++){
  52.         System.out.println(stus[i].info());
  53.         }
  54.     }
  56.     /**
  57.      * 查找Student数组中指定年级的学生信息
  58.      * @param stus 要查找的数组
  59.      * @param state 要查找的年级
  60.      */
  61.     public void searchState(Student1[] stus,int state){
  62.         for(int i = 0;i < stus.length;i++){
  63.             if(stus[i].state == state){
  64.                 System.out.println(stus[i].info());
  65.             }    
  66.         }
  67.     }
  69.     /**
  70.      * 对Student1数组进行冒泡排序
  71.      * @param stus
  72.      */
  73.     public void sort(Student1[] stus){
  74.         for(int i = 0;i < stus.length - 1;i++){
  75.             //冒泡的比较次数就是比数组长度少一，所以减1
  76.             for(int j = 0; j < stus.length - i - 1;j++){
  77.                 if(stus[j].score > stus[j + 1].score){
  78.                     //如果需要换序，交换的是数组的元素，Student对象！！！
  79.                     Student1 temp = stus[j];
  80.                     stus[j] = stus[j + 1];
  81.                     stus[j + 1] = temp;
  82.                 }
  83.             }
  84.         }
  85.     }
  87. }
  89. class Student1{
  90.     int number;//学号
  91.     int state;//年级
  92.     int score;//成绩
  94.     //显示学生信息的方法
  95.     public String info(){
  96.         return "学号：" + number + ",年级：" + state + ",成绩：" + score;
  97.     }
  98. }