类和对象

对象：

  • 万物皆对象，客观存在的事务皆为对象

    类：(java程序的基本组成单位)

  • 类是对现实生活中一类具有共同属性和行为的事务抽象
  • 特点：
    • 类是对象的数据类型
    • 类是具有相同属性和行为的一组对象的集合

      类是对象的模板，对象是类的一个个体，对应一个实例

      对象的属性：

  • 对象具有各种特征，每个对象的每个属性都具有特定的值

    对象的行为：

  • 对象能够执行的操作

    类的组成：

  • 属性：
    • 在类中通过成员变量来体现（类中方法外的变量）
    • 属性的定义语法同变量(访问修饰符 属性类型 属性名)
    • 属性的定义类型可以为任意类型(基本数据类型 引用数据类型)
    • 属性如果不赋值 有默认值 规则和数组一致
  • 行为：在类中通过成员方法来体现（和前面方法相比去掉static即可）

    类的定义步骤：

  • 定义类
  • 编写类的成员变量
  • 编写类的成员方法

    对象的使用：

  • 创建对象：
    • 格式：类名 对象名 = new 类名();
  • 使用对象：
    • 使用成员变量：
      • 格式：对象名.变量名
  • 使用成员方法：
    • 格式：对象名.方法名();

作用域

基本使用：

  • java中 主要的变量就是属性(成员变量)和局部变量
  • 局部变量一般在成员方法中定义的变量
  • 成员变量不赋值可直接使用(有默认值)
  • 局部变量必须赋值使用

    注意事项：

  • 成员变量和局部变量可以重名 访问遵循就近原则
  • 同一个作用域中 局部变量不能重名

成员变量和局部变量

区别：

  • 类中位置不同：
    • 成员变量在类中方法外
    • 局部变量在方法内或方法声明上
  • 内存中位置不同：
    • 成员变量在堆内存中
    • 局部变量在栈内存中
  • 声明周期不同：
    • 成员变量随对象存在而存在，随对象消失而消失
    • 局部变量随方法调用而存在，随方法调用完毕而消失
  • 初始化不同：
    • 成员变量有默认的初始化值
    • 局部变量没有默认初始化值，必须先定义赋值再使用
  • 作用域范围不同：
    • 成员变量可被本类与其他类使用
    • 局部变量只能在类中对应方法中使用
  • 修饰符不同:
    • 成员变量可以加修饰符
    • 局部变量不可以加修饰符

构造方法/构造器(constructor)

概述：

  • 构造方法是一种特殊方法

    格式：

  1. public class 类名 {
  2. 修饰符 类名(参数) {
  3. }
  4. }

    功能：

  • 主要是完成对新对象数据的初始化

    注意事项：

  • 构造方法的创建：
    • 如果没有定义构造方法，系统将给出默认的无参构造方法
    • 如果定义了构造方法，系统将不在提供默认的构造方法
  • 构造方法的重载：
    • 如果自定义了带参构造方法，还要使用无参构造方法，就必须再写一个无参构造方法
  • 说明：
    • 构造方法没有返回值
    • 方法名必须和类名一样
    • 构造方法的调用由系统完成
    • 一个类可以定义多个构造器 即构造器重载
    • 构造器是完成对象的初始化 不是创建对象

this关键字

  • this修饰的变量用于指代成员变量
  • 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
  • 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
  • 解决局部变量隐藏成员变量是使用this
  • this代表所在类的对象引用[方法被哪个对象调用，this就代表哪个对象]
  • this关键字可以用来访问本类的属性、方法、构造器
  • this用于区分当前类的属性和局部变量
  • 访问成员方法：this.方法名(参数列表)
  • 访问构造器：this(参数列表) 只能在构造器中调用另一个构造器 且须置于第一条语句
  • this不能在类定义的外部使用 只能在类定义的方法中属于

标准类的制作

成员变量：

  • 使用private修饰

    构造方法：

  • 提供一个无参构造方法
  • 提供一个带多个参数的构造方法

    成员方法：

  • 提供每个成员变量对应的setXxx()和getXxx()
  • 提供一个显示对象信息的show();

    创建对象并为其赋值的两种方式：

  • 无参构造方法创建对象后使用setXxx()赋值
  • 使用带参构造方法直接创建带有属性值的对象
  1. public static void main(String[] args) {
  2.     Cat c1 = new Cat();        //实例化对象
  3.     c1.name = "小橘";
  4.     c1.age = 1;
  5.     Cat c2 = new Cat();
  6.     c2.name = "小花";
  7.     c2.age = 2;                //访问对象属性
  8.     System.out.println(c1.name + "猫" + c1.age + "岁");
  9.     System.out.println(c2.name + "猫" + c2.age + "岁");
  10.     }
  11. }
  12. class Cat {            //定义一个猫类
  13.     String name;     //属性 成员变量
  14.     int age;
  15. }
  1. public static void main(String[] args) {
  2.     Person p1 = new Person();
  3.     p1.cal01(10);//调用方法同时赋值
  4. }
  5. class Person {
  6.     public void cal01(int n) {
  7.         int res = 0;
  8.         for (int i = 1; i <= n; i++) {
  9.             res += i;
  10.         }System.out.println(res);
  11.     }
  12. }
  1. public static void main(String[] args) {
  2.     int n1 = 20;
  3.     Num n = new Num();
  4.     n.num(n1);
  5.     System.out.println("main：" + n1);//基本数据类型 n1 = 20
  7.     int[] t = {1, 2, 3};
  8.     n.test(t);
  9.     System.out.print( "\n" + "mian: ");
  10.     for (int i : t) {
  11.         System.out.print(i + "\t");//引用数据类型 200 2 3
  12.     }
  13. }
  14. class Num {
  15.     public void num(int n1) {
  16.         n1 = 10;
  17.         System.out.println(n1); //10
  18.     }
  19.     public void test(int[] t) {
  20.         t[0] = 200;
  21.         for (int i : t) {    
  22.             System.out.print(i + "\t"); //200 2 3
  23.         }
  24.     }
  25. }

image-20211009225354380.png

  1. public class exaple041{
  2.     public static void main(String[] args) {
  3.         tes t = new tes();
  4.         int res = t.factorial(3);
  5.         System.out.println(res);
  6.     }
  7. }
  8. class tes{
  9.     public int factorial(int a) {
  10.         if (a == 1) {
  11.             System.out.print(a + " = ");
  12.             return 1;
  13.         }else {
  14.             System.out.print(a + " * ");
  15.             return factorial(a - 1) * a;
  16.         }
  17.     }
  18. }
  19. /3 * 2 * 1 = 6
  1. //猴子吃桃，每天吃掉桃子的一半加一颗，第十天剩余一个桃子
  2. public class exaple041{
  3.     public static void main(String[] args) {
  4.         tes t = new tes();
  5.         int a = t.peach(1);
  6.         if (a == -1){
  7.             System.out.println("数据超范围");
  8.         }else {
  9.             System.out.println(a);//1534
  10.         }
  11.     }
  12. }
  13. class tes {
  14.     public int peach(int day) {
  15.         if (day == 10) {
  16.             return 1;
  17.         } else if (day >= 1 && day <= 9) {
  18.             return (peach(day + 1) + 1) * 2;
  19.         } else {
  20.             return -1;
  21.         }
  22.     }
  23. }
  1. //将塔上按大小顺序的圆盘还原到另外的塔上
  2. //小盘上不能放大盘并在三个柱子上移动这些盘
  3. //一次只能移动一个盘
  4. public class exaple041{
  5.     public static void main(String[] args) {
  6.         Tower to = new Tower();
  7.         to.move(2, 'A', 'B', 'C');
  8.     }
  9. }
  10. class Tower {
  11.     //num表示盘的个数，a b c 分别表示 A塔 B塔 C塔
  12.     public void move(int num, char a, char b, char c) {
  13.         //如果只有一个盘 直接a盘移动到c盘
  14.         if (num == 1) {
  15.             System.out.println(a + "->" + c);
  16.         } else {
  17.             //如果有多个盘，则可看做两个盘，最低下的盘和上面所有盘
  18.             //先把上面所有盘移到b塔，借助c塔
  19.             move(num -1, a, c, b);//num = 1
  20.             //把最后的一个盘移动到c塔
  21.             System.out.println(a + "->" + c);
  22.             //把b塔上的所有盘移动到c塔，借助a塔
  23.             move(num - 1, b, a, c);//num = 0
  24.         }
  25.     }
  26. }