Java基础-Day09

Java基础-Day09

面向对象

面向对象学习 的三条主线

1. Java类及类的成员：属性、方法、构造器；代码块、内部类
2. 面向对象的大特征：封装性、继承性、多态性、抽象性
3. 其他关键字：this、super、static、final、abstract、interface、package、import等

面向对象与面向过程的理解

1. 面向过程：抢到的是功能行为，以函数为最小单位，考虑怎么做
2. 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做

面向对象中量重要的概念

• 类：对一个类事物的描述，是抽象的、概念上的定义
• 对象：是实际存在的该类事物的每个个体，因而也称为实例（instance）
  • 面向对象程序设计的重点是类的设计
  • 设计类，就是设计类的成员
• 二者的关系：
  • 对象，是由类new出来的，派生出来的

面向对象思想落地实现的规则

1. 创建类，设计类的成员
2. 创建类的对象
3. 通过“对象.属性”或“对象.方法”调用对象的结构

对象的创建于对象的内存解析

• 典型代码：

  Person p1 = new Person();
  Person p2 = new Person();
  Person p3 = p1;//没有新创建一个对象，共用了堆中对象的实体
  

  ​

• 实例

package com.lurenj.exer;

import java.sql.Struct;

public class StudentTest {
    public static void main(String[] args) {
        //声明Student类型的数组 String[] arr = new String[20];
        Student[] students = new Student[20];
        for (int i = 0; i < students.length; i++) {
            //给数组元素赋值
            students[i] = new Student();
            //给Student对象的属性赋值
            students[i].number = i + 1;
            //年级：[1,6]
            students[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
            students[i].score = (int)(Math.random() * (100 - 0 + 1));
        }
        //新建StudentTest对象
        StudentTest test = new StudentTest();
        //通过StudentTest类中的print方法遍历students对象
        test.print(students);//调用StudentTest对象中的方法
        System.out.println("**************************");
        //打印3年级（state值为3）的学生信息
        //通过StudentTest类中的searchState方法遍历students对象
        test.searchState(students,3);
        System.out.println("**************************");
        //通过StudentTest类中的sort方法，将学生成绩排序，并遍历所有学生信息
        test.sort(students);
        //遍历
        test.print(students);
    }


    //遍历Student[]数组的操作方法
    public void print(Student[] students){//需要Student[]类参数
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i].info());
        }
    }

    //查找Student数组中指定年级的学生信息
    public void searchState(Student[] students, int state){
        for (int i = 0; i < students.length; i++) {
            if (students[i].state == 3) {
                System.out.println(students[i].info());
            }
        }
    }

    //使用冒泡排序按学生成绩排序，并遍历所有学生信息
    public void sort(Student[] students){
        for (int i = 0; i < students.length - 1; i++) {
            for (int j = 0; j < students.length - 1 - i; j++) {
                if (students[j].score < students[j + 1].score){
                    //交换的temp临时变量也得和students[j]属于同类
                    Student temp = students[j];
                    students[j] = students[j + 1];
                    students[j + 1] = temp;
                }
            }
        }
    }


}

class Student{
    int number;//学号
    int state;//年级
    int score;//成绩

    //显示学生的信息方法
    public String info(){
            return  "学号：" + number + " 年级：" + state + " 成绩：" + score;
    }


}

方法的重载（overlord）

package com.lurenj.java;
/*
*
* 方法的重载（overlord）
* 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者
* 参数类型不同即可
*   "两同一不同"：同一个类、相同方法名
*               参数列表不同：参数个数不同，参数类型不同
* 2.判断是否是重载：
* 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
*
* */
public class OverLoad {

    public void  getSum(int i,int j){

    }
    public void getSum(double d1,double d2){

    }

    public void getSum(String s,int i){

    }
    public void getSum(int i,String s){

    }
}

可变个数形参

package com.lurenj.java;

public class MethodArgsTest {
    public static void main(String[] args) {
        MethodArgsTest test = new MethodArgsTest();
        test.show("hello","world");
    }
    public void show(int i){

    }

    //可变个数形参
    public void show(String ... strings){
        System.out.println("show(String ... strings) ");
    }
}

方法参数的值传递机制