JavaSE 第五章面向对象基础（上）

77 阅读 0 评论 51 点赞

我是靠谱客的博主健忘战斗机，这篇文章主要介绍JavaSE 第五章面向对象基础（上），现在分享给大家，希望可以做个参考。

文章目录

- 5.1 面向对象编程
- - 5.1.1 面向对象编程思想概述
  - - 5.1.1.1 编程语言概述
    - 5.1.1.2 程序设计方法
  - 5.1.2 类和对象
  - - 5.1.2.1 类
    - 5.1.2.2 对象（示例）
    - 5.1.2.3 类与对象的关系
  - 5.1.3 如何定义类
  - - 5.1.3.1 类的定义格式
    - 5.1.3.2 定义学生类
    - 5.1.3.3 定义手机类
  - 5.1.4 如何使用类
  - - 5.1.4.1 使用类对象
    - 5.1.4.3 如何调用实例方法
  - 5.1.5 对象的内存图
  - - 5.1.5.1 一个对象的内存图
    - 5.1.5.2 两个对象的内存图
    - 5.1.5.3 三个引用两个对象的内存图
  - 5.1.6 实例初始化
  - - 5.1.6.1 构造器
  - 5.1.7 实例变量与局部变量的区别
  - 5.1.8 匿名对象的概述和应用
  - - 5.1.7.1 匿名对象的概述
    - 5.1.7.2 匿名对象的应用场景
    - 5.1.7.3 匿名对象的好处
  - 5.1.9 对象数组
  - 5.1.10 包（Package）
  - - 5.1.10.1 包的作用
    - 5.1.10.2 声明包
    - 5.1.10.3 如何跨包实用类

5.1 面向对象编程

5.1.1 面向对象编程思想概述

5.1.1.1 编程语言概述

Java是一种计算机程序设计语言，所有的计算机程序一直都是围绕着两件事在进行的（如何表示和存储数据；基于这些数据都有什么操作行为，实现什么功能），程序设计就是用某种语言编写代码来完成这两件事，所以程序设计语言又称为编程语言。

如何表示数据和存储数据
复制代码 * 基于数据类型的变量和常量：表示和存储一个个独立的数据。 * 对象：表示和存储与某个具体事物相关的多个数据（如一个学生的姓名、年龄、性别、学号等等）。 * 数据结构：表示和存储一组数据，数据结构有数组、链表、栈、队列、散列表、树......
```
1
2
3
4
  * 基于数据类型的变量和常量：表示和存储一个个独立的数据。
  * 对象：表示和存储与某个具体事物相关的多个数据（如一个学生的姓名、年龄、性别、学号等等）。
  * 数据结构：表示和存储一组数据，数据结构有数组、链表、栈、队列、散列表、树......
```

基于这些数据能实现哪些功能
复制代码 * 数据的输入输出 * 数据间的赋值运算、算术运算、比较运算、逻辑运算...... * 基于一组数据的统计分析、查找元素、遍历......
```
1
2
3
4
  * 数据的输入输出
  * 数据间的赋值运算、算术运算、比较运算、逻辑运算......
  * 基于一组数据的统计分析、查找元素、遍历......
```

5.1.1.2 程序设计方法

程序设计方法分为面向过程和面向对象两种

面向过程的代表语言C语言，C语言是在面向过程思想的指引下去设计、去开发计算机程序的。
面向对象的代表语言Java，Java语言在面向对象思想的指引下去设计、去开发计算机程序的。

面向过程的程序设计思想（Process-Oriented Programming），简称POP

面向过程的程序设计思想关注的焦点是操作数据的步骤，如果某段代码被多次使用，那么就可以将这个过程抽象为一个函数，可以简化代码，减少冗余，也便于维护。

代码的结构是以函数为组织单位，独立于函数之外的数据称为全局数据，在函数内部的数据称为局部数据
.

面向对象的程序设计思想（Object Oriented Programming），简称OOP

面向对象的程序设计思想关注的焦点是类，在计算机程序设计过程中，参照现实中的事物，将事物的属性特征、行为特征抽取出来，用一个类来表示。某一个事物的具体个体称为示例或对象
代码结构是以类为组织单位。每种事物都具备自己的属性（属性是用来表示和存储数据的，在类中用成员变量来表示）和行为/功能（即对数据的操作，在类中用成员方法表示）

5.1.2 类和对象

5.1.2.1 类

类是一类具有相同特征的事物的抽象描述，是一组相关属性和行为的集合。（如拿姓名，年龄，性别就可以抽象出来一个人的类）Java中最基本的单位就是类，用来描述现实生活中的事物。
类的成员变量（属性）
- 描述该事物的状态信息

类的成员方法（行为）
- 该事物能做什么操作，有什么功能

5.1.2.2 对象（示例）

对象是一类事物的一个具体的个体，即一个对象的实例，必须具备该类事物的属性和行为

如对于学生类，它的实例可以是一个名叫张三的学生、也可以是名叫李四的学生

5.1.2.3 类与对象的关系

类是对一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实例

5.1.3 如何定义类

5.1.3.1 类的定义格式

复制代码

1
2
3
4
5
6
7
8
9
10
11
关键字：class

[修饰符] class 类名 {

}

如
public class Student {

}

类一般由五部分组成
- 成员变量/field域
- 成员方法（method）
- 构造器
- 代码块
- 内部类

5.1.3.2 定义学生类

复制代码

1
2
3
4
学生类
属性：姓名，年龄，性别
行为：学习，睡觉

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Student {  // 类名为Student
    String name ;   // 姓名属性
    int age ;       // 年龄属性
    String sex ;    // 性别属性

    public void study() {
        System.out.println(name + " 在学习.....");
    }

    public void sleep() {
        System.out.println(name + " 在睡觉.....");
    }

}

5.1.3.3 定义手机类

复制代码

1
2
3
4
手机类
属性：价格，品牌，颜色
行为：打电话，玩游戏，发信息

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Phone {    // 手机类
    String brand ;  // 品牌属性
    double price ;  // 价格属性
    String color ;  // 颜色属性
    
    public void call() {    // 打电话行为
        System.out.println("打电话......");
    }
    
    public void playGame() {    // 玩游戏属性
        System.out.println("玩游戏......");
    }
    
    public void sendMessage() { // 发信息行为
        System.out.println("发信息.....");
    }
}

5.1.4 如何使用类

在使用一个类时，我们必须对该类进行实例化，即创建该类的对象
创建对象的格式：类名对象名 = new 类名();
如何使用类中的成员变量
对象名.变量名
如何使用类中的成员方法
对象名.方法名([参数])

5.1.4.1 使用类对象

复制代码

1
2
类名 对象名 = new 类名();

案例：创建学生对象

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class StudentTest {
    public static void main(String[] args) {
        // 创建学生类对象
        Student student = new Student();

        // 调用其成员变量并赋值
        student.name = "张三" ;
        student.age = 21 ;
        student.sex = "男" ;

        // 调用成员方法
        student.sleep();
        student.study();

      	System.out.println(student);
    }
}

在这里插入图片描述

我们创建对象后对其成员变量进行赋值，输出对象，得到的是类是于直接输出数组的一个字符串，由此我们可以得到，对象名中存储的是对象的地址，对象是引用数据类型
“cn.pdsu.edu.Student@4554617c”也不是对象的地址，因为Java是对程序员隐藏内存地址的，不暴露内存地址信息，所以打印对象时不直接显示内存地址，而是JVM帮你调用了对象的toString方法，将对象的基本信息转换为字符串并返回，默认toString方法返回的是“对象的运行时类型@对象的hashCode值的十六进制值”，程序员可以自己改写toString方法的代码

在这里插入图片描述

成员变量
声明成员变量

复制代码

1
2
3
4
5
6
7
[修饰符] 数据类型 成员变量名;

如：
String name;
int age;
String sex;

注意

位置要求：成员变量必须定义在类中，方法外
类型要求：可以是任何类型的，包括基本数据类型，引用数据类型
修饰符：如public、static、protected、private…
其中static将变量分为两大类：静态变量和非静态变量，其中静态变量又称为类变量，非静态变量又称为实例变量或属性。

实例变量的特点

实例变量的值是属于某个对象的

必须通过对象才能访问实例变量
每个对象的实例变量的值是独立的

实例变量有默认值（对应数据类型的默认值）

访问实例变量：对象名.实例变量

案例：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student() ;
        Student s1 = new Student() ;

        s.name = "张三" ;
        s.age = 21 ;
        s.sex = "男" ;

        System.out.println("s.name = " + s.name);
        System.out.println("s.age = " + s.age);
        System.out.println("s.sex = " + s.sex);

        System.out.println("s1.name = " + s1.name);
        System.out.println("s1.age = " + s1.age);
        System.out.println("s1.sex = " + s1.sex);
    }
}

在这里插入图片描述

Java对象保存在内存中时，由以下三部分组成：

对象头

Mark Word：记录了和当前对象有关的GC、锁等信息。

指向类的指针：每一个对象需要记录它是由哪个类创建出来的，而Java对象的类数据保存在方法区，指向类的指针就是记录创建该对象的类数据在方法区的首地址。该指针在32位JVM中的长度是32bit，在64位JVM中长度是64bit。

数组长度（只有数组对象才有）

实例数据

即实例变量的值

对齐填充

因为JVM要求Java对象占的内存大小应该是8bit的倍数，如果不满足该大小，则需要补齐至8bit的倍数，没有特别的功能。

5.1.4.3 如何调用实例方法

方法调用的语法格式：对象.非静态方法([实参列表])

方法的特殊参数

形参是类类型（引用数据类型）

举例：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class TestStudent {
    public static void main(String[] args) {
        Student student = new Student();

        student.name = "张三" ;
        student.age = 15 ;

        print(student);
    }

    public static void print(Student s) {
        System.out.println(s.name);
        System.out.println(s.age);
        s.study();
    }

}

public class Student {  // 类名为Student
    String name ;   // 姓名属性
    int age ;       // 年龄属性

    public void study() {
        System.out.println(name + " 在学习.....");
    }

    public void sleep() {
        System.out.println(name + " 在睡觉.....");
    }

}

在这里插入图片描述

形参是可变参数

在JDK1.5之后，在定义一个方法时，形参的类型需要确定，但是形参的个数可以是不确定的，可以考虑使用可变参数可变参数的格式：参数类型… 参数名

可变参数的特点和要求：

一个方法最多只能有一个可变参数
如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个，前面传的参数默认给对应的参数赋值
在声明它的方法中，可变参数当成数组使用，个数范围从0到无穷大
举例：
先定义一个方法print(int[] arr) 参数列表是int数组,
再定义一个方法print(int… arr) 参数列表为可变参数会报错，不是方法的重载，而是同一个方法，可变参数等同于数组

在这里插入图片描述
案例：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Demo1 {
    public static void main(String[] args) {
        int[] arr = {11 , 22 , 33 , 44 , 55} ;
        print(100 , arr);
        print(arr);
    }

    public static void print(int j , int... arr) {
        System.out.println("j = " + j);
        for (int i = 0 ; i < arr.length ; i ++) {
            System.out.println(arr[i]);
        }
    }

    public static void print(int... arr) {
        for (int i = 0 ; i < arr.length ; i ++) {
            System.out.println(arr[i]);
        }
    }
}

在这里插入图片描述

参数类型为命令行参数

通过命令行给main方法的形参传递的实参称为命令行参数

复制代码

1
2
3
4
5
6
7
8
9
10
public class Demo2 {
    public static void main(String[] args) {
        System.out.println(args);
        System.out.println(args.length);
        for (int i = 0 ; i < args.length ; i ++) {
            System.out.println("第" + (i+1) + "个参数的值是：" + args[i]);
        }
    }
}

在这里插入图片描述

在IDEA中配置运行参数
在这里插入图片描述

配置参数后再次运行

方法的参数传递机制
- 方法的形参是基本数据类型时，形参值的改变不会影响实参

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Demo3 {
    public static void main(String[] args) {
        int a = 4 ;
        int b = 8 ;
        System.out.println("交换前a = " + a + " , b = " + b);
        swap(a , b);
        System.out.println("交换后a = " + a + " , b = " + b);
    }

    public static void swap(int a , int b) {
        int temp = a ;
        a = b ;
        b = temp ;
        System.out.println("方法内 ：交换后a = " + a + " , b = " + b);
    }
}

在这里插入图片描述

可以看到，即使在调用过交换方法后，再输出a、b仍为交换前的顺序。这是因为实参a、b是基本数据类型，传递给实参的是数据的"副本"，在调用完后，a、b的值不会发生任何的改变

方法的形参是引用数据类型时，形参地址值的改变不会影响实参，但是形参地址值里面的数据的改变会影响实参。

案例：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Demo4 {
    public static void main(String[] args) {
        int[] arr1 = {1 , 2 , 3} ;
        int[] arr2 = {3 , 2 , 1} ;

        System.out.println("交换前的arr1=" + arr1 + " , 交换前的arr2=" + arr2);
        swap(arr1 , arr2);
        System.out.println("交换后的arr1=" + arr1 + " , 交换后的arr2=" + arr2);

    }

    public static void swap(int[] arr1 , int[] arr2) {
        int[] temp = arr1 ;
        arr1 = arr2 ;
        arr2 = temp ;
        System.out.println("方法内：交换后的arr1=" + arr1 + " , 交换后的arr2=" + arr2);
    }
}

在这里插入图片描述

复制代码

public class Demo4 {
    public static void main(String[] args) {
        int[] arr1 = {1 , 2 , 3} ;
        int[] arr2 = {3 , 2 , 1} ;

System.out.print("arr1 : ");
        for (int i = 0 ; i < arr1.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

System.out.print("arr2 : ");
        for (int i = 0 ; i < arr2.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

System.out.println();
        swap(arr1 , arr2);

System.out.print("arr1 : ");
        for (int i = 0 ; i < arr1.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

System.out.print("arr2 : ");
        for (int i = 0 ; i < arr2.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

}

public static void swap(int[] arr1 , int[] arr2) {
        arr1[1] = 100 ;
        arr2[1] = 50 ;

System.out.print("方法内arr1 : ");
        for (int i = 0 ; i < arr1.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

System.out.print("方法内arr2 : ");
        for (int i = 0 ; i < arr2.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }
        System.out.println();

}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class Demo4 {
    public static void main(String[] args) {
        int[] arr1 = {1 , 2 , 3} ;
        int[] arr2 = {3 , 2 , 1} ;

        System.out.print("arr1 : ");
        for (int i = 0 ; i < arr1.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

        System.out.print("arr2 : ");
        for (int i = 0 ; i < arr2.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

        System.out.println();
        swap(arr1 , arr2);

        System.out.print("arr1 : ");
        for (int i = 0 ; i < arr1.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

        System.out.print("arr2 : ");
        for (int i = 0 ; i < arr2.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

    }

    public static void swap(int[] arr1 , int[] arr2) {
        arr1[1] = 100 ;
        arr2[1] = 50 ;

        System.out.print("方法内arr1 : ");
        for (int i = 0 ; i < arr1.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }

        System.out.print("方法内arr2 : ");
        for (int i = 0 ; i < arr2.length ; i ++) {
            System.out.print(arr1[i] + " , ");
        }
        System.out.println();

    }
}

在这里插入图片描述

5.1.5 对象的内存图

5.1.5.1 一个对象的内存图

案例：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Car {
    /**
     * 车名
     */
    String name ;
    /**
     * 车的颜色
     */
    String color ;

    public void run() {
        System.out.println(name + "在路上跑...");
    }
}

class CarTest {
    public static void main(String[] args) {
        Car car = new Car();
        car.name = "比亚迪" ;
        car.color = "黑色" ;

        car.run();
    }
}

在这里插入图片描述

5.1.5.2 两个对象的内存图

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Car {
    /**
     * 车名
     */
    String name ;
    /**
     * 车的颜色
     */
    String color ;

    public void run() {
        System.out.println(name + "在路上跑...");
    }
}

class CarTest {
    public static void main(String[] args) {
        Car car1 = new Car();
        Car car2 = new Car();
        
        car1.name = "比亚迪" ;
        car1.color = "黑色" ;

        car1.run();
    }
}

在这里插入图片描述

5.1.5.3 三个引用两个对象的内存图

在这里插入图片描述

5.1.6 实例初始化

5.1.6.1 构造器

对于对象，每次创建后，所有成员变量都是默认值，如果我们需要对其进行赋值操作，需要挨个进行，太麻烦了。我们能不能在创建对象时，直接为当前对象的某个或所有成员变量直接赋值呢。

构造器的作用
- 构造本类对象，对类的属性值（成员变量）进行初始化（赋值）
构造器的语法格式
- 构造器又叫构造方法，格式和方法类似但又不同

复制代码

1
2
3
4
5
6
7
8
9
10
[修饰符] class 类名 {
	[修饰符] 构造器名() {
    
    }
  
  	[修饰符] 构造器名(参数列表) {
  
  	}
}

注意事项

构造器在每次创建对象时都会执行
构造器的名字必须和它所在类的类名相同
构造器没有返回值，不需要返回值类型，也不需要void
如果在定义类时没有提供构造器，系统会默认给一个无参构造器，并且该构造器的修饰符默认与类的修饰符相同。但是如果在定义类时提供了有参构造器，那么系统将不再提供无参构造器，如果要使用需要自己定义。
构造器是可以重载的，可以是无参、一参、两参、多参
构造器的修饰符只能是权限修饰符

案例：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Teacher {
    String name ;
    int age ;
    String sex ;

    public Teacher() {
    }

    public Teacher(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public void getInfo() {
        System.out.println("姓名：" + this.name + ", 年龄：" + this.age + ", 性别：" + this.sex);
    }
}

class TeacherTest {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        Teacher t2 = new Teacher("张三" , 30 , "男");

        t1.getInfo();
        t2.getInfo();
    }
}

在这里插入图片描述

5.1.7 实例变量与局部变量的区别

声明位置和方式
- 实例变量声明在类中，方法外
- 局部变量声明在方法体中，或方法的形参、代码块中
在内存中存储的位置不同
- 实例变量在堆中存储（实例变量属于对象，对象进堆内存）
- 局部变量在栈中存储（局部变量属于方法，方法进栈内存）
生命周期
- 实例变量：和对象的生命周期一样，随着对象的创建而存在，随着对象被GC回收而消亡，而且每一个对象的实例变量是独立的。
- 局部变量：和方法调用的生命周期一样，每一次方法被调用而在存在，随着方法执行的结束而消亡，而且每一次方法调用都是独立。
作用域
- 实例变量除了可以在类中使用，还可以通过对象调用
- 只能在方法中使用
修饰符
- 实例变量：public、protected、private、final、…
- 局部变量：final
默认值
- 实例变量有默认值
- 局部变量没有默认值，需要手动初始化

5.1.8 匿名对象的概述和应用

5.1.7.1 匿名对象的概述

没有名字的对象即为匿名对象

5.1.7.2 匿名对象的应用场景

调用方法，仅仅只调用一次的时候
匿名对象可以作为实际参数传递

5.1.7.3 匿名对象的好处

节省代码
匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。

案例：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class User {
    String name ;
    int age ;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void getInfo() {
        System.out.println("User{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}');
    }
}

class TestUser {
    public static void main(String[] args) {
        User user = new User("张三" , 25);
        method(new User("李四" , 20));	// 匿名内部类
        method(user);
    }

    public static void method(User user) {
        user.getInfo() ;
    }
}

在这里插入图片描述

5.1.9 对象数组

对象数组，首先要创建数组对象本身，确定数组的长度，然后再创建每一个元素对象，如果不创建，数组元素的默认值就是null，容易出现空指针异常NullPointerException。

案例：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class Person {
    String name ;
    int age ;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sleep() {
        System.out.println(name + "在睡觉......");
    }

    public void eat() {
        System.out.println(name + "在吃东西......");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

class PersonTest {
    public static void main(String[] args) {
        Person[] pArr = new Person[3] ;
        Person p1 = new Person("张三" , 20);
        Person p2 = new Person("李四" , 21);
        Person p3 = new Person("王五" , 22);

        pArr[0] = p1 ;
        pArr[1] = p2 ;
        pArr[2] = p3 ;

        for (int i = 0 ; i < pArr.length ; i ++) {
            System.out.println(pArr[i]);
        }
    }
}

在这里插入图片描述

5.1.10 包（Package）

5.1.10.1 包的作用

避免了的重名，将类创建在包里，类的全路径名称为包名.类名
控制某些类型或成员的可见范围
- 如果某个类型或者成员的修饰符缺省的话，那么就仅限于本包使用
分类组织管理不同类型的类

例如：

java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread等，提供常用功能

java.net----包含执行与网络相关的操作的类和接口。

java.io ----包含能提供多种输入/输出功能的类。

java.util----包含一些实用工具类，如集合框架类、日期时间、数组工具类Arrays，文本扫描仪Scanner，随机值产生工具Random。

5.1.10.2 声明包

关键字：package

复制代码

1
2
package 包名;

注意：

包的声明必须在源文件的代码首行
一个源文件只能有一个声明包的package语句

包的命名规范和习惯：

所有单词都小写，每个单词之间使用 . 分割
习惯用公司的域名倒置开头

5.1.10.3 如何跨包实用类

注意：只有public的类才能被跨包使用

使用类的全路径名称

如：java.util.Scanner sc = new java.util.Scanner(System.in) ;

使用import语句导包后可简化书写
import语句语法格式
- import 包名.类名;
- import 包名.*;

使用java.lang包下的类，不需要import语句，就直接可以使用简名称

import语句必须在package下面，class的上面

当使用两个不同包的同名类时，例如：java.util.Date和java.sql.Date。一个使用全名称，一个使用简名称

举例：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package cn.pdsu.edu;

import java.util.Date;
import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in) ;
        Student student = new Student() ;   // 同一个包下的类

        Date date = new Date() ;
        java.sql.Date date1 = new java.sql.Date(1) ;
    }
}

最后

以上就是健忘战斗机最近收集整理的关于JavaSE 第五章面向对象基础（上）的全部内容，更多相关JavaSE内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：java
浏览次数：77 次浏览
发布日期：2024-01-12 06:05:49
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_ogf0_12__7__2_3.html

JavaSE 第五章面向对象基础（上）

文章目录

5.1 面向对象编程

5.1.1 面向对象编程思想概述

5.1.1.1 编程语言概述

5.1.1.2 程序设计方法

5.1.2 类和对象

5.1.2.1 类

5.1.2.2 对象（示例）

5.1.2.3 类与对象的关系

5.1.3 如何定义类

5.1.3.1 类的定义格式

5.1.3.2 定义学生类

5.1.3.3 定义手机类

5.1.4 如何使用类

5.1.4.1 使用类对象

5.1.4.3 如何调用实例方法

5.1.5 对象的内存图

5.1.5.1 一个对象的内存图

5.1.5.2 两个对象的内存图

5.1.5.3 三个引用两个对象的内存图

5.1.6 实例初始化

5.1.6.1 构造器

5.1.7 实例变量与局部变量的区别

5.1.8 匿名对象的概述和应用

5.1.7.1 匿名对象的概述

5.1.7.2 匿名对象的应用场景

5.1.7.3 匿名对象的好处

5.1.9 对象数组

5.1.10 包（Package）

5.1.10.1 包的作用

5.1.10.2 声明包

5.1.10.3 如何跨包实用类

最后

评论列表共有 0 条评论

发表评论取消回复

JavaSE 第五章 面向对象基础（上）

文章目录

5.1 面向对象编程

5.1.1 面向对象编程思想概述

5.1.1.1 编程语言概述

5.1.1.2 程序设计方法

5.1.2 类和对象

5.1.2.1 类

5.1.2.2 对象（示例）

5.1.2.3 类与对象的关系

5.1.3 如何定义类

5.1.3.1 类的定义格式

5.1.3.2 定义学生类

5.1.3.3 定义手机类

5.1.4 如何使用类

5.1.4.1 使用类对象

5.1.4.3 如何调用实例方法

5.1.5 对象的内存图

5.1.5.1 一个对象的内存图

5.1.5.2 两个对象的内存图

5.1.5.3 三个引用两个对象的内存图

5.1.6 实例初始化

5.1.6.1 构造器

5.1.7 实例变量与局部变量的区别

5.1.8 匿名对象的概述和应用

5.1.7.1 匿名对象的概述

5.1.7.2 匿名对象的应用场景

5.1.7.3 匿名对象的好处

5.1.9 对象数组

5.1.10 包（Package）

5.1.10.1 包的作用

5.1.10.2 声明包

5.1.10.3 如何跨包实用类

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

JavaSE 第五章面向对象基础（上）

发表评论取消回复