定义

类(Class)和对象(Object)是面向对象的核心概念

  • 类是对一类事物的描述，是抽象的、概念上的定义
  • 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)

类及类的成员

  • 属性
  • 方法

例，构建一个人的类：

  1. // 创建类
  2. class Person{
  3.     // 属性
  4.     String name;
  5.     int age;
  6.     boolean isMarried;
  8.     // 方法
  9.     public void walk(){
  10.         System.out.println("walking");
  11.     }
  13.     public void display(){
  14.         return "Name : " + name + " , Age : " + age + " , Married : " + isMarried;
  15.     }
  16. }
  18. // 测试类
  19. public class Test{
  20.     public static void main(String[] args){
  21.         // 创建对象
  22.            Person P = new Person();
  24.         // 调用对象的属性
  25.         P.name = "nanase";
  26.         P.age = 25;
  27.         P.isMarried = false;
  29.         // 调用对象的方法
  30.         P.walk();
  31.         P.display();
  32.     }
  33. }

对象的内存解析

属性与局部变量

  • 属性
    • 具有权限修饰符
    • 加载到堆

  • 局部变量

    • 必须赋初值

    • 加载到栈

      1. class Person{
      2. // 属性
      3. String name;
      4. int age;
      5. boolean isMarried;
      7. public void walk(int speed){ // 形参即局部变量
      8.    System.out.println("speed is " + speed);
      9. }
      10. public void display(){
      11.    String food = ""; // 局部变量
      12.    return "Name : " + name + " , Age : " + age + " , Married : " + isMarried;
      13. }
      14. }

      方法

  • 描述类具有的功能

例，构建一个客户的类：

  1. class Customer{
  2.     String name;
  3.     int age;
  4.     boolean isMarried;
  6.     public void eat(){
  7.         System.out.println("eating");
  8.     }
  9.     public void sleep(int hour){
  10.         System.out.println("hour + " + hour);
  11.     }
  12.     public String getName(){
  13.         return name;
  14.     }
  15.     public String getNation(String nation){
  16.         String info = "My Nation is " + nation;
  17.         return info;
  18.     } 
  19. }

方法的声明

  • 权限修饰符
    • private、public、protected、缺省
  • 返回值类型
  • 方法名
  • 形参列表

练习：
定义类Student，包含三个属性:
学号number(int)，年级state(int)，成绩score(int)。
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一:打印出3年级(state值为3)的学生信息。
问题二:使用冒泡排序按学生成绩排序，并遍历所有学生信息

(对象数组)

  1. public class StudentTest {
  2.     public static void main(String[] args) {
  3.         Student[] stu = new Student[20];
  4.         for(int i = 0 ; i < 20 ; i ++ ){
  5.             stu[i] = new Student();
  6.             stu[i].id = i + 1;
  7.             stu[i].grade = (int)(Math.random() * (6 - 1 + 1) + 1);
  8.             stu[i].score = (int)(Math.random() * (100 - 0 + 1));
  9.         }
  10.         System.out.println("Q1:");
  12.         // 问题1
  13.         for(int i = 0 ; i < 20 ; i ++ ){
  14.             if(stu[i].grade == 3){
  15.                 System.out.println("学号 : " + stu[i].id + " 年级 : " + stu[i].grade + " 成绩 : " + stu[i].score);
  16.             }
  17.         }
  18.         System.out.println("Q2:");
  19.         // 问题2
  20.         for(int i = 0 ; i < 19 ; i ++ ){
  21.             for(int j = 0 ; j < 20 - i - 1 ; j ++ ){
  22.                 if(stu[j].score > stu[j + 1].score){
  23.                     Student temp = stu[j];
  24.                     stu[j] = stu[j + 1];
  25.                     stu[j + 1] = temp;
  26.                 }
  27.             }
  28.         }
  30.         // 遍历学生信息
  31.         for(int i = 0 ; i < 20 ; i ++ ){
  32.             System.out.println("学号 : " + stu[i].id + " 年级 : " + stu[i].grade + " 成绩 : " + stu[i].score);
  33.         }
  34.     }
  35. }
  37. class Student {
  38.     int id; // 定义学号
  39.     int grade; // 定义年级
  40.     int score; // 定义成绩
  41. }

方法的重载

  • 两同一不同：同类同方法名，不同参数列表

例如：

  1. public void println(byte x) 
  2. public void println(short x)
  3. public void println(int x)
  4. public void println(long x)
  5. public void println(float x)
  6. public void println(double x)
  7. public void println(char x) 
  8. public void println(double x)
  9. public void println()

可变个数的形参

  • JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
  • 只能有一个。

例如：

  1. public class Demo{
  2.     public void show(int i){
  3.         System.out.println("int : " + i);
  4.     }
  5.     public void show(String s){
  6.         System.out.println("String : " + s);
  7.     }
  8.     public void show(String ... strs){
  9.         System.out.println("String ... strs ");
  10.     }
  11. }

方法参数的传递机制

值传递机制

  • 形参是基本数据类型:将实参基本数据类型变量的“数据值”传递给形参
  • 形参是引用数据类型:将实参引用数据类型变量的“地址值”传递给形参

递归方法

  • 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
  • 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

例如，计算1-100之间所有自然数的和：

  1. public int sum(int n){
  2.     if(n == 1){
  3.         return 1;
  4.     }
  5.     return sum(n - 1) + n;
  6. }

斐波那契：
例如，1 1 2 3 5 8 13 21 34 55…
当 类和对象及其属性和方法(方法的重载) - 图1 时：

  • 类和对象及其属性和方法(方法的重载) - 图2
  • 类和对象及其属性和方法(方法的重载) - 图3

当 类和对象及其属性和方法(方法的重载) - 图4 时：

  • 类和对象及其属性和方法(方法的重载) - 图5 ```java import java.util.Scanner;

public class Fib { public static void main(String[] args) { Scanner input = new Scanner(System.in); Fib method = new Fib(); int n = input.nextInt(); System.out.println(“fib(“ + n + “) = “ + method.fib(n)); } public int fib(int n){ if(n <= 2){ return 1; } return fib(n - 1) + fib(n - 2); } } ```