类和对象

Posted 2020-11-30 zachyoung

类和对象

1、什么是类

在现实生活中，我们所理解的具有相同特性的归为一类，在 Java 语言中，也是如此。

我们对 相似的事物具有的属性和行为抽象出来，构建成一个类。

2、什么是对象

• 在 Java 中万物皆为对象

• 对象 也称作实例 （ instance ）

• 对象是对类的一种实例，也是一种具体

3、实例化

• 将抽象的类实例化一个具体的个体 比如猴子类中 有金丝猴

• 在 java 中 通过 new 关键字调用构造方法 来对一个类的实例化

4、对象

 在 java 语言中 ，对象( object ) 和 实例( instance )都是指 new 类名(); 方式创建出来的 对象
 类 是某一种事物的抽象  比如 人，动物，.....
 对象 是 某种事物的一个具体的个体，比如 叫张三的 人 ....

• 实例化

• 访问字段 通过 对象名.字段名 来访问字段

• 调用方法 通过 对象名.方法名 ([参数])来调用方法

• 所谓 对象名 就是指 相应类型的 的引用变量的名称

5、字段 （ Field ）

 字段 本质上是一个变量 是属于类中的一个成员 ( member ) 因此也称作 成员变量
 某一种事物的每个个体都具有的特征可以使用 字段来表示， 比如 某人的姓名、年龄、....

1、声明

修饰符 类型 名称 [ = 初始值 ]

2、字段的命名规则

• 不能使用数字作为前缀

• 如果只有一个单词则全部小写 （ 注意规范 ）

• 如果有多个单词则从第二个单词开始首字母大写 （ 注意规范 ）

3、本质

字段就是一个变量

这个变量可能属于类也可能属于实例对象

4、成员变量

• 字段就是类的组成成员，因此被称作成员变量

• 类变量：有 static 修饰的成员变量

• 实例变量： 没有 static 修饰的成员变量

6、类变量 和 实例变量

类变量：有 static 修饰的成员变量

实例变量： 没有 static 修饰的成员变量

7、static 修饰符

• 在一个类中被 static 修饰的成员 是属于类的（不是属于个体的）

• static 表示与类相关的（不是与实例相关的）

• 成员变量

  • 类变量 有 static 修饰的成员变量

  • 实例变量： 没有 static 修饰的成员变量

• 成员方法

  • 类方法（也称作静态方法）

• 代码块

  • 被 static 修饰的代码块 被称作为 静态代码块 （类初始化块）

  • 被 static 修饰的代码块 用来完成对 类变量初始化

 不论是 类变量 还是 实例变量，JVM 都会为他们赋予相对应的默认值

8、方法 （ Method ）

1、声明：

修饰符 返回类型 方法名称 ( 参数类型，参数名称..... ) { } throws 异常类型列表

2、成员方法：

• 方法时类的组成成员 因此被称作 成员方法

• 类方法

  • 通过 “类名.方法名（ 参数 ）” 来调用【推荐】

  • 通过 “对象名.方法名（ 参数 ）” 来调用【不推荐】

• 实例方法

  • 通过 “对象名.方法名（ 参数 ）”来调用

     1、一个带有 main 方法类是可以直接运行的，这样的类被称作 启动类
     2、首次 【主动使用】 一个类时，将导致该类被初始化，类中的类变量也将初始化
     3、所谓 【主动使用】 一个类包括很多情况，比如这里直接运行的一个启动类，或者创建一个类的对象
     4、当一个类被初始化后即可反复使用，不会再次执行初始化操作【除非该类被卸载后重新加载】
     5、static 代码块仅在首次主动使用一个类时，才执行一次

     

3、参数传递

不论基本类型 还是引用类型的参数 在Java 语言中 都是 值传递 只不过引用类型传递的值时地址而已

4、返回类型

方法的返回值类型 根据需要设定 当不需要返回值的时候 使用 void

5、重载（ overload ）

5.1、概念

同一个类中，存在多个同名不同参的方法时，这些方法就构成了 重载

同名不同参：

同名： 方法名称完全相同

不同参： 参数的 类型、个数、类型的顺序不同

 package oop;
 ?
 /**
  *  1、方法的重载，
  *  同一个类中存在多个同名不同参的方法时，他们之间构成重载 （ 重载是相互的）
  *  所谓同名是指 方法名称完全相同
  *  所谓不同参是指 构成重载的多个方法的参数类型、参数个数、参数顺序 不相同 （ 只要有其中一项不相同即可 ）
  *  重载 对 方法的 修饰符可以相同可以不同
  * */
 ?
 public class SikaDeer {
 ?
     public int add(int a,int b) {
         System.out.println("add(int,int)");
         return a + b;
     }
     public double add(double a,double b) {
         System.out.println("add(double,double)");
         return a + b;
     }
     public double add(int a,double b) {
         System.out.println("add(int,double)");
         return a + b;
     }
     public double add(double a,int b) {
         System.out.println("add(double,int)");
         return a + b;
     }
     public double add(double a,double b,double c) {
         System.out.println("add(double,double,double)");
         return a + b + c;
     }
 ?
     public static void main(String[] args) {
         SikaDeer sikaDeer = new SikaDeer();
 ?
 ?
         int num = sikaDeer.add(100, 200);
         System.out.println(num);
 ?
         System.out.println("==========");
 ?
         double num2 = sikaDeer.add(100.0, 200D);
         System.out.println(num2);
 ?
         System.out.println("==========");
 ?
         double num3 = sikaDeer.add(100, 200D);
         System.out.println(num3);
 ?
         System.out.println("==========");
 ?
         double num4 = sikaDeer.add(100.0, 200);
         System.out.println(num4);
 ?
         System.out.println("==========");
 ?
         double num5 = sikaDeer.add(100, 200,300);
         System.out.println(num5);
 ?
     }
 ?
 }
 ?

5.2、其他

• 修饰符可以相同可以不同

• 方法的返回类型可以相同可以不同

• 抛出异常类型可以相同可以不同

根据调用方法时，传入的实际参数时，来确定哪个方法

5.3、可变长参数

 package encapsulation;
 ?
 /**
  *  在一个方法的参数列表中，以...形式定义的参数就是可变长参数
  *  在一个方法的参数列表中至少出现一个 可变长参数 并且必须是形参列表的最后一个
  *  jdk 1.5 老特性：可变长参数
  *
  * */
 ?
 public class Bus {
     public void launch(String driver,String...passenger) {
         System.out.println(driver + "师傅为你服务");
         // 在方法内部，可变长参数
         // 调用 launch 方法时 如果可变长参数部分直接传入的 就是 null 则导致 passenger 变量 就是 null
         if (passenger != null) {
 ?
             if (passenger.length > 0) {
                 System.out.println("车上乘客有：");
                 for (int i = 0; i < passenger.length; i++) {
                     System.out.println(passenger[i] + " " );
                 }
             }
 ?
         }
     }
 ?
     public static void main(String[] args) {
 ?
         Bus bus = new Bus();
 ?
         String driver = "卡巴斯基";
         bus.launch(driver); // 注意第二个参数没有指定
         bus.launch(driver,"孙悟空"); // 在可变长参数 中传入一个参数
         bus.launch(driver,"孙悟空","牛魔王");
         bus.launch(driver,"孙悟空","牛魔王","红孩儿");
     }
 }
 ?

9、构造方法 （ Constructor ）

什么是构造

• 一种特殊的方法

• 与当前类名同名

• 不能显式声明返回类型

• 不能使用 static 修饰符修饰

通过构造方法来完成对一些字段的初始化

10、执行顺序

1、类体括号中 可以出现 字段、构造、方法、代码块，但不能直接出现语句 2、执行顺序 代码块 > 构造方法 3、实例的初始化过程； 通过 new 关键字创建对象时， 首先为实例变量分配空间并为实例变量赋予默认值， 然后执行 实例代码块， 最后执行 构造方法中的代码

 

11、静态代码块 和 实例代码块

静态代码块：

用于对 static 修饰的类变量进行初始化

实例代码块：

用于对 没有 static 修饰的 实例变量进行初始化

两者优先于构造函数的执行

 package oop;
 ?
 public class Lion {
 ?
     public static String home;
 ?
     public String name;
 ?
     static { // 静态代码块：直接在类体括号中书写的，有 static 修饰的、用来对 类变量 进行初始化的 代码块
         System.out.println( "instance code block" );
         home = "大草原";
     }
     { // 实例代码块：直接在类体括号中书写的、用来对实例变量进行初始化的代码块
         System.out.println( "instance code block" );
         this.name = "辛巴"; // 暂时不考虑通过构造方法传递参数 而是直接指定固定值
 ?
     }
 ?
     public Lion(){
         System.out.println( "构造方法：" + this.name );
     }
 ?
     public static void main( String[] args ){
         System.out.println( Lion.home );
 ?
         System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
 ?
         Lion first = new Lion();
         System.out.println( first.name);
 ?
         System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
 ?
         Lion second = new Lion();
         System.out.println( second.name);
     }
 ?
 }
 ?