Java（三）——类和对象（封装、包、代码块）

最新推荐文章于 2024-07-12 16:26:30 发布
最新推荐文章于 2024-07-12 16:26:30 发布
阅读量931 收藏 25
点赞数 29
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaokuer_/article/details/139012478
版权

文章目录

类和对象

之前我们学习过Java的基本知识、方法和数组。但是有不少遗留问题，包括调用数组类的方法对数组进行方便的操作。

面向对象

Java是一门面向对象的语言（OOP），在Java中，一切皆对象。面向对象是解决问题的一种思想，注重对象之间的交互。

以洗衣服为例，面向过程（如C语言）会关注洗衣服的过程：

拿盆子——>放水——>放衣服——>放洗衣粉——> … ——>晾衣服

而面向过程，关注的就是不同的对象：

人、衣服、洗衣粉、洗衣机

整个过程是由这4个对象（可以更多）之间的交互完成的，我们不需要关注洗衣机是如何洗衣服的，是如何甩干的

类和对象的初步认识

什么是类？什么是对象？它们的关系？

类是用来对一个实体（对象）来进行描述的。

面向对象的程序设计关注的是对象，对象就是生活中的实体，如某某同学就是一个具体的对象，要描述某某同学，就要知道他的"属性"，包括：名字、学号、年龄等，我们将这些属性归纳起来放在一个类中。

类是抽象的一种自定义类型，对象则是一个真实存在的实体。

比如，某某同学就是一个真实存在的对象，我们可以定义一个学生类来描述这一对象。

类的定义

类是来描述一个对象的，对象是一个真正存在的实体。类又可以叫类型，利用这一类型可以创建一个变量。

类是一个自定义的类型，可以用来定义变量

Java的类与C语言的结构体有相似之处，理解了结构体的定义，对理解类的定义有帮助，我们在用C语言做通讯录项目时，需要描述一个联系人的信息，将能描述一个联系人的信息存储在一个结构体中。而Java中的类不仅可以有成员变量，还可以有成员方法。

【创建类】

class 类名 {
	字段/属性/成员变量
	
	方法/成员方法/行为
}
  • 类名 采用 大驼峰命名方式
  • 字段/属性/成员变量 在 类内，成员方法外 定义
  • 初期所有的成员变量都要使用public修饰，public是访问修饰限定符的一种，后面会讲到
  • 一般一个Java文件中只定义一个类
  • main方法所在的类一般要使用public修饰（注意：Eclipse默认会在public修饰的类中寻找main方法）
  • public修饰的类必须要和文件名相同

我们先尝试定义一个狗类：

public class Dog {
    
        public String name;//狗的名字
        public int age;//狗的年龄
        public String color;//狗的颜色
        public String kind;//狗的品种
        
        //狗的吃行为    
        public void eat(){
            System.out.println(name + "吃骨头");
        }
        //狗的叫行为
        public void bark(){
            System.out.println("汪汪汪~~~");
        }
        
}

对于成员变量和成员方法，我们先将前面都加上public修饰符，public修饰的成员变量和方法可以随意访问，后面会讲到其他的访问修饰限定符：private、protected

类的实例化

前面提到，类只是一种类型，有了这个类，我们就能使用这个类定义对象。

用类类型创建对象的过程，称为类的实例化。需要用到new关键字。

public class Dog {
    
        public String name;
        public int age;
        public String color;
        public String kind;

        public void eat(){
            System.out.println(name + "吃骨头");
        }
        public void bark(){
            System.out.println("汪汪汪~~~");
        }
        
}

class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog();//实例化了一个狗对象
        
    }
}

当我们实例化了一个对象后，这个对象就实际存在了，将会在堆区申请一块空间，存放这个对象的信息，而上代码中的dog1实际上是引用变量，这一引用指向了实例化的狗对象。

我们可以打印一下，验证dog1是一个引用变量：

在这里插入图片描述

  • Demo1是自定义的包名，这个Dog类在此包中，什么是包，后面讲

  • Dog是类名

  • @是分隔符

  • 1b6d3586就是引用指向的对象的地址

我们可以实例化多个对象，对象之间的成员变量并不矛盾，因为实例化了多个对象，相当于每个对象在堆区都有一块自己的空间，我们通过下面的一段代码和内存图来理解：

    public static void main(String[] args) {
        Dog dog1 = new Dog();
        Dog dog2 = new Dog();
    }

在这里插入图片描述

访问对象

有了一个对象后，我们想要对它的成员变量进行赋值和访问，就要用到：

对象的引用.成员方法/成员变量

例如：

public class Dog {

        public String name;
        public int age;
        public String color;
        public String kind;

        public void eat(){
            System.out.println(name + "吃骨头");
        }
        public void bark(){
            System.out.println("汪汪汪~~~");
        }


}

class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        dog1.name = "dahuang";
        dog1.age = 12;
        dog1.color = "黄";
        dog1.kind = "田园犬";
        
        dog1.eat();
    }
}

在这里插入图片描述

补充一个知识点：我们知道，Java中局部变量未初始化就使用，编译器会报错，而成员变量未初始化使用不会报错。

局部变量都是在方法内定义的，而成员变量是在类内、方法外定义的。

【局部变量未初始化】

    public static void main(String[] args) {
        int a;
        System.out.println(a);
    }

在这里插入图片描述

【成员变量未初始化】

    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }

在这里插入图片描述

我们发现，成员变量没有初始化就使用并没有报错，且打印的值是一个默认值，对于基本类型，默认值是其对应的 0 值（boolean类型初始为false）；引用变量初始默认值为null

this关键字

this代表当前对象的引用，谁调用就是谁的引用。

this引用的是调用成员方法的对象

我们通过一个例子引出this关键字：我们现在想对成员变量赋值太麻烦了，我们可以定义一个成员方法，每次调用这个成员方法即可完成赋值，同时实现一个打印成员变量的成员方法：

public class Dog {

        public String name;
        public int age;
        public String color;
        public String kind;

        public void eat(){
            System.out.println(name + "吃骨头");
        }
        public void bark(){
            System.out.println("汪汪汪~~~");
        }

        public void setDog(String name, int age, String color, String kind) {
            name = name;
            age = age;
            color = color;
            kind = kind;
        }
        
        public void printDog() {
            System.out.println("名字：" + name);
            System.out.println("年龄：" + age);
            System.out.println("颜色：" + color);
            System.out.println("品种：" + kind);
        }

}

我们看到，上面的成员方法的形参名与当前类的成员变量名重复了，这种情况下，能设置成功吗，我们验证一下：

    public static void main(String[] args) {
        Dog dog1 = new Dog();
        dog1.setDog("dahuang", 12, "huang", "tianyuanquan");
        dog1.printDog();
    }

在这里插入图片描述

为什么会出现这样的情况呢？

    //同名
    public void setDog(String name, int age, String color, String kind){
        name = name;
        age = age;
        color = color;
        kind = kind;
    }

在方法内，name、age、color、kind都是局部变量，此时局部变量优先使用。

按照上面的解释，我们方法体的语句逻辑就是：形参给形参赋值。当然不会改变成员变量的值。

【解决方案一】

改变成员方法形参名（不推荐）

【解决方案二】

使用this关键字

        public void setDog(String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
        }

this关键字就是当前对象的引用，当前对象的引用.成员变量 就能访问到该对象的成员变量，再进行赋值，就可以。

在这里插入图片描述

那么问题来了，我们在调用成员方法时，Java是如何确定当前的对象的呢？

我们看一段代码：

        public void setDog(Dog this, String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
        }

对于成员方法，我们在第一个形参位置加上Dog this，并没有报错，这是因为Java的成员方法默认有隐藏的第一个参数，通过这个参数，this就能确定当前对象的引用。

我们总结一下有关this的一部分知识：

  • 习惯使用this，可以避免很多不必要的错误。基于此，我们上面实现的打印方法体内也要加上this
  • this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
  • this只能在成员方法中使用（可以在构造代码块使用，本文后面会讲），不能在静态方法中使用。this可以在非静态代码块中使用，其实，非静态方法的花括号内部也就是一块非静态代码块。（代码块的知识后面会讲）
  • 在成员方法中，this只能引用当前对象，不能再引用其他对象
  • this是成员方法第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法的对象的引用传递给改成员方法，this负责接收
  • this的用法：
    1. this.成员变量：访问当前对象的成员变量
    2. this.成员方法：访问当前对象的非静态成员方法
    3. this()：调用当前类的其他构造方法

关于this访问当前对象的成员变量，我们在引出this的例子中已经演示了，接下来我们先演示this访问当前对象的非静态成员方法。

将前面实现的赋值方法与打印方法合并，达到赋值后接着打印的效果：

public class Dog {

        public String name;
        public int age;
        public String color;
        public String kind;

        public void eat(){
            System.out.println(name + "吃骨头");
        }
        public void bark(){
            System.out.println("汪汪汪~~~");
        }

        public void setDog(Dog this, String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
            this.printDog();//this访问成员方法
        }

        public void printDog() {
            System.out.println("名字：" + this.name);
            System.out.println("年龄：" + this.age);
            System.out.println("颜色：" + this.color);
            System.out.println("品种：" + this.kind);
        }

}

class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setDog("dahuang", 8, "huang", "labuladuo");
    }
}

在这里插入图片描述

用法三需要了解构造方法的知识，我们接下来讲。

构造方法

构造方法（也称为构造器）是一个特殊的成员方法，名字必须与类相同，没有返回值（这里指不需要写返回值，而不是将返回值写成void)，在创建对象时，由编译器自动调节，并且在整个对象的生命周期内只调用一次。

构造方法的作用是给对象的成员变量初始化。

【语法格式】

修饰符 方法名(参数列表) {
	方法体
}
  • 绝大多数情况下被public修饰，极少特殊情况下被private修饰
  • 方法名与类名相同
  • 支持重载

其实，我们在实例化对象的时候，就调用了构造方法：
在这里插入图片描述

一个对象的生成至少需要两步：

  • 为对象分配内存空间
  • 调用合适的构造方法

构造方法可以自定义且支持重载，如果没有显性定义构造方法，Java会自动提供一个不带参数的空构造方法，反过来，如果显性定义了构造方法，Java就不自动提供构造方法了。

上面的理论解释了为什么我们没有定义构造方法还能创建对象使用空构造方法。

我们实现两个构造方法：一个不带参数，一个带参数。

public class Dog {

        public String name;
        public int age;
        public String color;
        public String kind;

        public void eat(){
            System.out.println(name + "吃骨头");
        }
        public void bark(){
            System.out.println("汪汪汪~~~");
        }

        public void setDog(Dog this, String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
            this.printDog();
        }

        public void printDog() {
            System.out.println("名字：" + this.name);
            System.out.println("年龄：" + this.age);
            System.out.println("颜色：" + this.color);
            System.out.println("品种：" + this.kind);

        }

       //带4个参数的构造方法
        public Dog(String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
        }
       //不带参数的构造方法
        public Dog() {

        }

}

我们可以调用合适的构造方法：

    public static void main(String[] args) {
        Dog dog1 = new Dog();
        Dog dog2 = new Dog("泥鳅", 3, "黑黄相间", "中华田园犬");
        dog1.printDog();
        System.out.println("==========");
        dog2.printDog();
    }

在这里插入图片描述

了解完构造方法后，我们补充this的第三种用法：调用当前类的其他构造方法

public class Dog {

        public String name;
        public int age;
        public String color;
        public String kind;

        public void eat(){
            System.out.println(name + "吃骨头");
        }
        public void bark(){
            System.out.println("汪汪汪~~~");
        }

        public void setDog(Dog this, String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
            this.printDog();
        }

        public void printDog() {
            System.out.println("名字：" + this.name);
            System.out.println("年龄：" + this.age);
            System.out.println("颜色：" + this.color);
            System.out.println("品种：" + this.kind);

        }

        public Dog(String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
        }

       //this()调用当前类的其他构造方法
        public Dog() {
            this("皮皮", 3, "黑白相间", "中华田园犬");
        }

}

class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.printDog();
    }

}

打印结果如下：

在这里插入图片描述

打印结果显示，this()调用了当前类的带4个参数的构造方法。

注意：

  • 如果要使用this()调用当前类的其他构造方法，这条语句必须是方法体的第一句
  • 不能形成环（不允许两个构造方法互相调用）

IDEA快速生成构造方法：

  1. 在类内部区域，右击鼠标，出现以下选项卡，点击红框选项：

    在这里插入图片描述

  2. 继续点击红框区域：

    在这里插入图片描述

  3. 选择构造方法的参数列表：（如下例，如果想生成4个参数的构造方法，全选）

    在这里插入图片描述

  4. 点击OK，生成成功！

    在这里插入图片描述

对象的初始化

  1. 构造方法初始化
  2. 默认初始化
  3. 就地初始化

构造方法初始化上面已经介绍了。

【默认初始化】

这就要再提一下前面补充的一个知识点：局部变量在使用时必须要初始化，成员变量不用

那么具体是为什么呢？

我们想搞清楚为什么，就需要知道new关键字背后发生的事情:

Dog dog = new Dog("泥鳅", 4, "黄黑", "中华田园犬");

执行这条语句，JVM层面做了很多的事情：

    1. 检测对应的类是否被加载，如果没有加载则加载

    Java源代码经过Javac编译后生成字节码文件，而字节码文件会被加载到JVM中运行，字节码文件加载到Java虚拟机的过程就叫做加载。

    这里涉及到Java的一个优点：被加载过的类不会再被加载

    联想到C语言中的预处理过程，会将包含的头文件中的所有数据直接拷贝到源代码中（包括用不到的），并且如果同一个头文件重复出现，也会拷贝两份，从中能够看出Java的一些优势

    1. 为对象分配内存空间
    1. 处理并发问题
    1. 初始化所分配的空间

    对象空间被申请好了之后，对象中包含的成员已经设置好了初始值：

    为全局变量赋值_Java中局部变量、成员变量、全局变量与数组的初始化-CSDN博客

    1. 设置对象头信息
    1. 调用构造方法初始化

【就地初始化】

就地初始化即 在声明成员变量时，就直接给出初始值。

public class Dog {

        public String name = "大黄";
        public int age = "2";
        public String color = "黄色";
        public String kind = "中华田园犬";

        public void eat(){
            System.out.println(name + "吃骨头");
        }
        public void bark(){
            System.out.println("汪汪汪~~~");
        }
}

注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造方法中

封装

对于 面向对象的语言 来说，有几个重要的特性：封装 、继承、 多态

而在类和对象阶段，我们主要研究封装性。

我们主要讨论：

什么是封装？（封装的概念）

为什么要封装？（封装的意义）

代码层面实现封装（封装的实现）

【封装的概念】

封装：将数据和操作数据的方法有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

关于封装，就类似于我们平时使用的手机，手机的内部电路构造被手机壳屏蔽了，我们看不到其中的细节，不过也不是完全封装起来，手机商给用户留了很多接口，如充电接口、耳机接口，还有屏幕，能让用户和手机完成交互即可。

【封装的意义】

  • 提高代码安全性、私密性

    把对象的私有数据和公共数据分离开，保护了私有数据，减少了模块间的干扰

  • “高内聚”

    封装细节，便于修改内部代码，提高可维护性

  • “低耦合”

    简化外部调用，便于调用者使用，便于扩展和协作

【封装的实现】

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，而访问权限用来控制方法或者字段能否直接在类内外使用。

Java提供4种访问修饰限定符实现封装，分别是：private、default、protected、public

Java四种访问控制修饰符 - 叨叨宅

  • 其中default就是 没有访问控制修饰符 的情况，表示默认权限
  • protected涉及到子类，子类在Java的继承部分，这里不介绍
  • public即公开权限，没有限制
  • private是私有权限，被private修饰的成员变量或方法只能在当前类使用
  • 注意一点：private、protected不能修饰类，这是语法不允许的

public不做过多介绍，protected在笔者之后的有关继承的博客会介绍。我们主要介绍private以及default(默认权限)。

private

我们将我们之前实现的Dog类的所有成员变量和部分成员方法改成由private修饰，然后测试private影响的访问权限：

public class Dog {
        private String name;
        private int age;
        private String color;
        private String kind;

        public void eat(){

            System.out.println(name + "吃骨头");
        }
        public void bark(){

            System.out.println("汪汪汪~~~");
        }

        private void printDog() {
            System.out.println("名字：" + this.name);
            System.out.println("年龄：" + this.age);
            System.out.println("颜色：" + this.color);
            System.out.println("品种：" + this.kind);
        }

        public Dog(String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
        }

        public Dog() {

        }
}

我们测试的方式是：在Dog(当前类)和Main(其他新建的类)中分别定义一个main方法，分别测试，看能否访问成功：

public class Dog {
        private String name;
        private int age;
        private String color;
        private String kind;

        public void eat(){

            System.out.println(name + "吃骨头");
        }
        public void bark(){

            System.out.println("汪汪汪~~~");
        }

        private void printDog() {
            System.out.println("名字：" + this.name);
            System.out.println("年龄：" + this.age);
            System.out.println("颜色：" + this.color);
            System.out.println("品种：" + this.kind);
        }

        public Dog(String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
        }

        public Dog() {

        }

        public static void main(String[] args) {
            Dog dog = new Dog("泥鳅", 1, "黑黄", "松狮");
            dog.age = 2;//直接方法访问private修饰的成员变量
            dog.printDog();//直接访问private修饰的成员方法
        }
}

在这里插入图片描述

上例证明被private修饰的成员变量和成员方法可以在当前类访问

class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("小黄", 3, "黄", "田园犬");
        dog.name = 4;
        dog.printDog();
    }
}

在这里插入图片描述

上例证明被private修饰的成员变量和成员方法不可以在其他类访问

那么，如何在其他类中访问private修饰的成员变量和成员方法呢？

与手机的处理方式一样，我们给用户提供一个接口，让用户间接地访问。

这里就涉及到get、set方法（针对成员变量），而private修饰的成员方法，我们一般在当前类中新建一个由合适的访问限定修饰符修饰的方法，调用private修饰的方法，这样就既隐藏了代码，又不妨碍用户使用，我们直接看代码：

public class Dog {
        private String name;
        private int age;
        private String color;
        private String kind;

        public void eat(){

            System.out.println(name + "吃骨头");
        }
        public void bark(){

            System.out.println("汪汪汪~~~");
        }

        private void printDog() {
            System.out.println("名字：" + this.name);
            System.out.println("年龄：" + this.age);
            System.out.println("颜色：" + this.color);
            System.out.println("品种：" + this.kind);
        }
        //调用private修饰的成员方法
        public void printInfo() {
            this.printDog();
        }

        public Dog(String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
        }

        public Dog() {

        }
        //get方法
        public String getName() {
            return this.name;
        }

        public int getAge() {
            return this.age;
        }
        //set方法
        public void setName(String name) {
            this.name = name;
        }

        public void setAge(int age) {
            this.age = age;
        }
        
        public static void main(String[] args) {
            Dog dog = new Dog("泥鳅", 1, "黑黄", "松狮");
            dog.age = 2;
            dog.printDog();
        }
}

实现了上述接口，我们就可以在其他类中使用成员变量和成员方法了：

class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //给对象赋值
        dog.setName("大哈");
        dog.setAge(4);
        //打印信息
        System.out.println(dog.getName());
        System.out.println(dog.getAge());
        dog.printInfo();
    }
}

在这里插入图片描述

IDEA快速生成get、set：

  1. 在当前类的区域右击鼠标，点击Generate...

    在这里插入图片描述

  2. 选择生成get、set或get和set方法

    在这里插入图片描述

  3. 选择要生成get和set方法的成员变量，IDEA会自动检测没有生成的，且生成的不予显示：

    在这里插入图片描述

default（默认权限）

默认权限就是包访问权限，只能在当前类所在的包内访问，我们简单介绍一下，之后我们就介绍包。

先将Demo1包中的Dog类的成员变量和部分成员方法改成默认权限：

public class Dog {
        //修改为默认权限
        String name;
        int age;
        String color;
        String kind;

        public void eat(){

            System.out.println(name + "吃骨头");
        }
        public void bark(){

            System.out.println("汪汪汪~~~");
        }
        //修改为默认权限
        void printDog() {
            System.out.println("名字：" + this.name);
            System.out.println("年龄：" + this.age);
            System.out.println("颜色：" + this.color);
            System.out.println("品种：" + this.kind);
        }

        public void printInfo() {
            this.printDog();
        }

        public Dog(String name, int age, String color, String kind) {
            this.name = name;
            this.age = age;
            this.color = color;
            this.kind = kind;
        }

        public Dog() {

        }

        public String getName() {
            return this.name;
        }

        public int getAge() {
            return this.age;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void setAge(int age) {
            this.age = age;
        }
    
}

我们先验证同包的可访问性：(在Dog包中新建其他类访问)

class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "大哈";
        dog.age = 4;
        dog.printDog();
    }
}

在这里插入图片描述

能够直接访问，证明了默认权限同包的可访问性。

接下来，我们验证一下不同包的不可访问性：

下图显示我们的Dog类在Demo1包中：

在这里插入图片描述

我们新建一个包：

在这里插入图片描述

在新建包Demo2中新建一个Test类：

在这里插入图片描述

在Test类中实例化一个对象并尝试直接访问：

package Demo2;//声明该类所在包，后面由类的部分专门讲

import Demo1.Dog;//导入Dog类，后面有类的部分专门讲

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "叶子";
        dog.age = 5;
        dog.printDog();
    }
}

在这里插入图片描述

我们只能依靠get、set和提供的其他接口访问：

package Demo2;

import Demo1.Dog;

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("叶子");
        dog.setAge(5);
        dog.printInfo();
    }
}

在这里插入图片描述

到这里，我们应该体会到了面向对象语言的封装特性。

包

包的概念

在面向对象的体系中，提出了软件包的概念。为了更好地管理类，把多个类收集在一起成为一组，称为软件包。

类比文件夹，为了更好地管理不同的文件，我们选择将具有相同属性的文件放到相同文件下，并可以不断分类。

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等很好的组织方式， 比如，我们可以使用包和合适的限定符，达到一个包中的类不能在其他包中的类使用的效果；另外，包还解决了类名命名冲突的问题，在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

导入包中的类

Java中已经提供了很多现成的类供我们使用，例如我们在数组部分经常使用的Arrays类，导入这些类需要关键字import

我们介绍三种导入包中类的方式：

  1. 不使用import
  2. 使用import导入具体的类
  3. 使用import和通配符*导入某个包中的所有类

我们想要创建一个Date类（Java现成类）的对象：

【不使用import】

public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
    }
}

不导入包，就要在使用Date类时加上其所在路径（或者理解成包名称、子包名称），不过这太麻烦了。

【使用import导入具体的类】

import java.util.Date;//导入Date类

public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

【使用import和通配符*导入包中所有类】

util包中不止有Date类，我们常用的数组Arrays类也在里面，我们可以使用通配符*导入util包中的所有类，具体用法如下：

import java.util.*;//使用通配符

public class Test {
    public static void main(String[] args) {
        
        Date date = new Date();
        System.out.println(date.getTime());
        
        int[] array = new int[]{1, 2, 3};
        System.out.println(Arrays.toString(array));
        
    }
}

不过，我们还是建议显式地指定要导入的类名，否则还是容易出现冲突的情况。

说到这，我们举几个例子体会一下导入包时的注意事项：

如我们要使用Date这个类，而util和sql两个包中都有Date类（重名）

【情况一】

import java.util.Date;
import java.sql.Date;
//报错！！！

在这里插入图片描述

【情况二】

import java.util.*;
import java.sql.*;

public class Package {
    public static void main(String[] args) {
        Date d = new Date();//报错！！！
        java.util.Date d2 = new Date();
    }
}

在这里插入图片描述

【情况三】

import java.util.Date;
import java.sql.*;

public class Package {
    public static void main(String[] args) {
        Date d = new Date();
        java.util.Date d2 = new Date();
    }
}
//不报错

不报错，不过此时的Date是哪个包中的？util还是sql？

其实是util包里的，util的Date类实例化时为无参构造方法，而sql的Date类实例化时没有无参构造方法。所以，在上面的import情况下，我们可以直接使用Date实例化一个对象，使用无参构造方法，如果报错，证明：不指明路径使用Date类，默认是sql包中的，如果不报错，证明默认是util包中的。

以下证明：

import java.util.Date;
import java.sql.*;

public class Package {
    public static void main(String[] args) {
        Date d = new Date();
    }
}

在这里插入图片描述

并没有报错，证明：

如果存在重名类，优先使用的是没有使用通配符的包里的类，而要使用另一个重名的类，则需要使用第一种导入包的方式，在使用时加上路径，以区分重名类

【静态导入】

还有一个知识点：静态导入。

如果一个类中的方法全部是使用 static 声明的静态方法，则在导入时就可以直接使用 import static 的方式导入：

结果将会导入包中的静态方法和字段，静态导入的意义在于，它能够简化代码，使得我们更加方便。

静态导入的格式：

import static 包.类.*;

例如：

import static java.lang.Math.*;//静态导入

public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;

        //不静态导入，常规写法
        double ret1 = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));

        //静态导入，可简写
        double ret2 = sqrt(pow(x, 2) + pow(y, 2));

        System.out.println(ret1);
        System.out.println(ret2);
    }
}

在这里插入图片描述

【注意】

Java的import与 C++的#include差别很大。C++必须用#include来引入其他文件内容，而Java的import只是为了写代码的方便。

自定义包

自定义包要用到package关键字，指定代码所在包。

注意：

  • package语句声明了当前类所在的包
  • 包名尽量指定成唯一的名字，通常会用公司域名的颠倒形式（如：com.baidu.www)
  • 包名要和代码路径相匹配，例如创建com.xiaokuer.www的包，那么会存在一个对应的路径com/xiaokuer/www来存储代码
  • 如果一个类没有使用package语句，呢么该类会被放到一个默认包中

我们接下来在IDEA中演示一下：

  1. 先按照下图打开包的命名界面

    在这里插入图片描述

  2. 按照上面建议的命名方式命名，例如com.xiaokuer.www

    在这里插入图片描述

  3. 起好名字后按下回车

    在这里插入图片描述

  4. 上面提到了，创建例如com.xiaokuer.www为包名的包，会生成com/xiaokuer/www的路径，我们可以查看一下：

    在这里插入图片描述
    在这里插入图片描述

  5. 我们可以调整一下IDEA对于自定义包的显示：（将对号取消）

在这里插入图片描述

在这里插入图片描述

调整之后，就更加直观了。

  1. 我们在www路径下创建一个类：

    在这里插入图片描述

  2. 命名好后，我们发现，在新建的.java文件的上方自动生成了package语句，声明了其所在包：

    在这里插入图片描述

包的访问权限控制

即通过访问限定符限定成员变量或成员方法，这部分内容在本文 封装 部分已经介绍了，这里不再赘述。

常用的包

  1. java.lang：系统常用基础类（String、Object），此包从JDK1.1后自动导入
  2. java.lang.reflect：java反射编程包
  3. java.net：进行网络编程开发包
  4. java.sql：进行数据库开发的支持包
  5. java.util：是Java提供的工具程序包。
  6. java.io：I/O编程开发包

static成员

static修饰成员变量

static修饰的成员变量，称为静态成员变量，也可以称为类成员。静态成员变量：不属于某个具体的对象，是所有对象所共享的。（这一点相当重要）

【静态成员变量的特性】

  • 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

  • 访问方法：1. 通过类名访问 2. 通过对象访问

    我们推荐通过类名访问

  • 类成员存储在方法区中

  • 类变量的生命周期伴随类的一生，随着类的加载而创建，随类的卸载而销毁

为了介绍上面的特性，我们仍然使用类Dog，添加一个成员变量owner，代表狗狗的铲屎官。

我们假设此类描述的都是同一个人家的狗狗，那么，我们实例化的每个对象的owner成员变量一致，都是同一个人。

此时，如果每个实例化的狗狗都要带上这个属性且要初始化太麻烦了，我们就可以采用static修饰成员变量的方式解决这个问题：

package com.xiaokuer.www;

public class Dog {
    public String name;
    public int age;
    public String color;
    public String kind;
    public static String owner;

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public Dog(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public Dog() {

    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }
}

我们将owner成员变量用static修饰，此时owner依赖于对象，也不在某个对象的空间内，而是在在方法区。

【验证】静态成员变量不在某个对象的空间，而是在方法区：

package com.xiaokuer.www;

public class DemoOne {
    public static void main(String[] args) {
        Dog dog1 = new Dog("大哈", 3, "黄白", "哈士奇");
        Dog dog2 = new Dog("叶子", 4, "黑白", "边牧");
        dog1.owner = "猪爸";

        dog1.printDog();
        System.out.println("========");
        dog2.printDog();
    }
}

如代码显示，我们通过dog1对象访问并设置静态成员变量的值，然后打印两个对象的信息：

在这里插入图片描述

发现：两个对象打印出来的owner信息都是通过dog1对象访问设置好的信息。

【验证】静态成员变量不依赖于对象

    public static void main(String[] args) {
        Dog.owner = "猪爸";
    }

我们直接设置静态成员变量owner的值即可，不需要实例化对象。

【静态成员访问的方法】

  1. 通过类名访问
  2. 通过对象的引用访问

通过类名访问不再赘述，其反映了静态成员变量的不依赖对象性。

关于通过对象的引用访问静态成员变量，实际上对象的引用为null也不影响：

    public static void main(String[] args) {
        Dog dog = null;
        dog.owner = "猪爸";
        System.out.println(dog.owner);
    }

在这里插入图片描述

静态成员变量不依赖于对象，所以没有抛出"空指针异常"。

static修饰成员方法

static修饰的成员方法，称为静态成员方法，也叫类方法，是类的方法，不是某个对象所特有

【静态成员方法的特性】

  • 静态成员方法不依赖于对象，不属于某个具体的对象
  • 访问方法：1. 类名访问 2. 对象调用
  • 不能在静态方法中直接访问任何非静态成员变量
  • 不能在静态方法中直接调用任何非静态方法。前面提到静态方法中有隐藏的this参数，this与对象强相关，在静态方法中调用时无法传递this引用
  • 静态方法无法重写，不能用来实现多态

我们看一段代码：

public class Dog {
    public String name;
    public int age;
    public String color;
    public String kind;
    public static String owner;

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public Dog(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public Dog() {

    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }
    
    
    //静态方法中直接访问非静态成员变量
    public static void test() {
        age += 1;
        this.name = "大哈";
    }
}

在这里插入图片描述

要想在静态方法中访问非静态的成员变量，必须实例化对象，通过对象的引用访问非静态成员变量：

    public static void test() {
        Dog dog = new Dog();
        dog.age += 1;
        dog.name = "大哈";
        dog.printDog();
    }

我们验证：静态方法不依赖于对象，可以直接通过类名调用

public class DemoOne {
    public static void main(String[] args) {
        Dog.test();
    }
}

在这里插入图片描述

在非静态方法中可以调用静态方法，反之不可：

public class Dog {
    public String name;
    public int age;
    public String color;
    public String kind;
    public static String owner;

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public Dog(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public Dog() {

    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }

    public static void test() {
        Dog dog = new Dog();
        dog.age += 1;
        dog.name = "大哈";
        dog.printDog();
    }

    //非静态方法调用静态方法，不报错！
    public void useStatic() {
        //写法一
        test();
        //写法二
        Dog.test();
    }

    //静态方法直接调用非静态方法，报错！
    public static void useNonStatic() {
        printDog();
    }
}

要想在静态方法调用非静态方法，必须实例化对象，用对象的引用调用非静态方法。

static成员变量初始化

三种方法：

  • 就地初始化
  • 静态代码块初始化
  • 构造方法初始化

【就地初始化】

即，定义时直接初始化：

public class Dog {
    public String name;
    public int age;
    public String color;
    public String kind;
    //就地初始化
    public static String owner = "猪爸";

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public Dog(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public Dog() {

    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }
    
}

【静态代码块初始化】

代码块是一个新知识点，我们在这里给出代码，具体知识点在本文的后面介绍：

public class Dog {
    public String name;
    public int age;
    public String color;
    public String kind;
    public static String owner;
    
    //静态代码块初始化
    static {
        //写法一
        owner = "猪爸";
        //写法二
        Dog.owner = "猪爸";
    }

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public Dog(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public Dog() {

    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }
}

【构造方法初始化】

这一方法不常用，给出代码：

//构造方法    
public Dog(String owner) {
        Dog.owner = owner;
    }

public class DemoOne {
    public static void main(String[] args) {
        //构造方法初始化
        Dog dog = new Dog("猪爸");
        System.out.println(Dog.owner);
    }
}

代码块

代码块的概念

使用{}定义的一段代码称为代码块。

根据代码块的定义位置以及关键字，可分为以下四种：

  • 普通代码块
  • 构造/实例代码块
  • 静态代码块
  • 同步代码块（多线程部分内容，暂时不讨论）

普通代码块

普通代码块，即定义在方法中的代码块。

是方法定义的一部分。

public class DemoOne {
    public static void main(String[] args) {
        //普通代码块
        int a = 10;
        int b = 20;
        System.out.println(a + b);
    }
}

构造代码块

构造代码块，又称实例代码块，即定义在类中的不加修饰符的代码块。

一般用来初始化实例成员变量。

格式：

{
    //语句
}

关于构造代码块，我们要讨论的事情较多：

  • 构造代码块的执行时机
  • 构造代码块的执行次数
  • 不同构造代码块初始化的结果（多个构造代码块的执行顺序）

我们先写一段代码：

public class Dog {
    private String name;
    private int age;
    private String color;
    private String kind;
    private static String owner;

    //构造代码块
    {
        this.name = "大哈";
        this.age = 3;
        //用于检验构造代码块的执行时机和次数
        System.out.println("构造代码块执行了");
    }

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }
    
    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }
}

了解了构造代码块的书写后，请问：构造代码块何时执行？执行几次？

构造代码块在实例化对象时执行。每次实例化对象时都会执行一次。

验证：

    public static void main(String[] args) {
        System.out.println("不实例化对象，观察是否打印构造代码块中的语句：");
    }

在这里插入图片描述

结果是：不执行。

    public static void main(String[] args) {
        System.out.println("实例化对象，观察是否打印构造代码块中的语句：");
        Dog dog = new Dog();
    }

在这里插入图片描述

执行了！

    public static void main(String[] args) {
        System.out.println("实例化多个对象，观察是否多次打印构造代码块中的语句：");
        Dog dog1 = new Dog();
        Dog dog2 = new Dog();
    }

在这里插入图片描述

验证构造代码块的初始化效果：

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.printDog();
    }

在这里插入图片描述

到此，我们验证了构造代码块的执行时机和执行次数，接下来我们看一段代码，说出main方法执行后打印结果是什么：

public class Dog {
    private String name;
    //就地初始化age为2
    private int age = 2;
    private String color;
    private String kind;
    private static String owner;

    //构造代码块一，初始化age为3
    {
        this.age = 3;
    }

    //构造代码块二，初始化age为4
    {
        this.age = 4;
    }

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.age);
    }
}

在这里插入图片描述

结果是 4。给出结论：当代码块的属性一样（都是构造代码块）时，初始化的最后结果与定义顺序有关，最终值是最后初始化的值（如果就地初始化在所有构造代码块后面，则最终的值为就地初始化的值）

我们调整顺序验证：

public class Dog {
    private String name;

    {
        this.age = 3;
    }

    {
        this.age = 4;
    }
    
    private int age = 2;
    private String color;
    private String kind;
    private static String owner;
    

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.age);
    }
}

在这里插入图片描述

验证成功！

【总结】

  • 构造代码块在实例化对象（创建对象时）执行，执行次数与实例化的对象的个数保持一致

  • 当定义的多个代码块的属性一样（都是构造代码块）时，初始化的最后结果与定义顺序有关，最终值是最后初始化的值

    或者说：多块构造代码块的执行顺序与定义顺序有关

静态代码块

静态代码块，即使用static定义的代码块。

一般用于初始化静态成员变量

格式：

static{
    //语句
}

我们依旧讨论：

  • 静态代码块的执行时机
  • 静态代码块的执行次数
  • 多个静态代码块初始化的结果（多个静态代码块的执行顺序）

我们给出结论：静态代码块在类被加载时执行，且只会执行一次

验证：

public class Dog {

    private String name;
    private int age;
    private String color;
    private String kind;
    private static String owner;

    //静态代码块
    static {
        owner = "小裤儿";
        //检验静态代码块的执行时机和执行次数
        System.out.println("静态代码块被执行了");
    }

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }

    public static void main(String[] args) {
        System.out.println("不实例化对象，观察是否打印静态代码块中的语句：");
    }
}

在这里插入图片描述

执行了！且执行时机很早（加载类时）。

我们尝试实例化多个对象，观察：

    public static void main(String[] args) {
        System.out.println("实例化多个对象，观察：");
        Dog dog1 = new Dog();
        Dog dog2 = new Dog();
    }

在这里插入图片描述

静态代码块只会在加载类时执行一次！

多个静态代码块的执行顺序，说出main方法执行的打印结果：

public class Dog {

    private String name;
    private int age;
    private String color;
    private String kind;
    private static String owner = "猪爸";

    static {
        owner = "小裤儿";
    }

    static {
        owner = "四角儿";
    }

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }

    public static void main(String[] args) {
        System.out.println(Dog.owner);
    }
}

在这里插入图片描述

与多个构造代码块一样，与执行顺序有关。

当代码块的属性一样（都是静态代码块）时，初始化的最后结果与定义顺序有关，最终值是最后初始化的值（如果就地初始化在所有静态代码块后面，则最终的值为就地初始化的值）

交换顺序验证：

public class Dog {

    private String name;
    private int age;
    private String color;
    private String kind;

    static {
        owner = "小裤儿";
    }

    static {
        owner = "四角儿";
    }
    
    private static String owner = "猪爸";

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }

    public static void main(String[] args) {
        System.out.println(Dog.owner);
    }
}

在这里插入图片描述

验证成功！

【总结】

  • 静态代码块在类加载时执行，同一个类只会加载一次，所以静态代码块只会执行一次

  • 当代码块的属性一样（都是静态代码块）时，初始化的最后结果与定义顺序有关，最终值是最后初始化的值（如果就地初始化在所有静态代码块后面，则最终的值为就地初始化的值）

    多块静态代码块的执行顺序与定义顺序有关

不同代码块、构造方法的执行顺序

类中总会出现构造代码块、静态代码块都存在的情况，这种情况下，执行顺序是什么？加上构造方法呢？

我们在代码块中加入打印语句，当打印出对应语句时，证明代码块执行：

public class Dog {

    private String name;
    private int age;
    private String color;
    private String kind;
    private static String owner;

    //构造函数
    public Dog(String name, int age, String color, String kind) {
        System.out.println("构造方法被执行了");
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    //构造代码块
    {
        System.out.println("构造代码块被执行了");
    }

    //静态代码块
    static {
        System.out.println("静态代码块被执行了");
    }

    public void eat() {
        System.out.println(this.name + " 吃饭");
    }

    public void setInfo(String name, int age, String color, String kind) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.kind = kind;
    }

    public void printDog() {
        System.out.println("名字：" + this.name);
        System.out.println("年龄：" + this.age);
        System.out.println("颜色：" + this.color);
        System.out.println("品种：" + this.kind);
        System.out.println("铲屎官：" + this.owner);
    }

    public static void main(String[] args) {
        Dog dog = new Dog("大哈", 3, "黄白", "哈士奇");
    }
}

在这里插入图片描述

由打印结果可知：执行顺序：静态代码块 > 构造代码块 > 构造方法

它们的执行顺序与定义顺序无关，是固定的。

对象的打印

对象的打印，我们可以通过自定义一个成员方法即可打印，不过，如果类的成员变量过多，我们实现打印函数就会十分麻烦。

这里介绍一个简单的方法：IDEA生成

  1. 在类的区域右击，出现以下选项卡，红框区域

    在这里插入图片描述

  2. 选择下图红框的toString

    在这里插入图片描述

  3. 选择想打印的成员方法

    在这里插入图片描述

  4. 生成
    在这里插入图片描述

  5. 调用

        public static void main(String[] args) {
        Dog dog = new Dog();
        //传入对象的引用
        System.out.println(dog);
    }

    在这里插入图片描述

为什么？按照惯例，我们打印的应该是一个"地址"。

其实这里是：toString的重写，需要继承和多态的知识，我们先看现象即可。

上面就是本文的全部内容了，希望对大家有所帮助！
预告：继承和多态

四角小裤儿儿
关注
  • 29
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java——类和对象超详细总结
weixin_49215278的博客
11-03 2002
文章目录类和对象1.类与对象的初步认识2.类和类的实例化3.类的成员3.1字段/属性/成员变量3.2方法3.3 static关键字4.封装4.1 private实现封装4.2 getter和setter方法5.构造方法5.1基本语法5.2 this关键字6.认识代码块6.1什么是代码块6.2普通代码块6.3构造代码块6.4静态代码块 类和对象 1.类与对象的初步认识 c语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 Java是基于面向对象的，关注的是对象，将一件事情拆分成不
java代码-java代码——猜数字游戏，限制次数。
07-15
2. **类和对象**：在Java中，每个实体（如玩家、游戏）都被封装为一个类，而类的实例称为对象。例如，我们可以创建Game对象来启动游戏，并创建Player对象来表示玩家。 3. **随机数生成**：在`NumberGenerator`类中...
Java基础——类和对象
热门推荐
explorer363的博客
04-26 3万+
本篇博客介绍了Java中类和对象的基本内容，看完本篇博客后，希望大家能对类和对象能有进一步的了解
Java面向对象之——封装
LEE180501的博客
11-23 2546
本期主要探讨了面向对象三大特性之一的封装，重点介绍了Java包的概念、引入了静态属性static、详细介绍了Java中的三种代码块、最后拓展了一下IDEA中的小技巧，欢迎阅读！
Java类和对象（二）—— 封装，static 关键字与代码块
hong_z_c的博客
05-15 637
封装，static，代码块，权限访问修饰符，对象初始化
Educoder/头歌JAVA——JAVA面向对象：常用类
舟舟的博客
12-17 1万+
本实训项目的主要内容是介绍 Java 类库所提供的常用类及类的常用方法， Java 中常用的类有： Object类； Java 基础类型包装类； String&StringBuilder&StringBuffer类； Random类； Date类； SimpleDateFormat类； Math类。 在前面的实训中，我们已经学习了 Java 基础类型包装类和String类，接下来我们将学习其他 4 种 Java 常见的类.
java面向对象编程——类和对象
bug郭的博客
11-23 3031
兄弟们好久不见，失踪人口回归！ bug郭时隔将近一个月终于更新了！！！ 写在前面 bug郭学习了java的一些基础语法。今天我们来分享一下java重要语法的多态的学习！ java中的语法学习起来不像数据结构一样带劲，语法就比较枯燥和死板，并且要记忆的东西很多！还有跳不完的坑！但是不要慌，bug郭和你一起加油，把重要的语法java多态学习一下 文章目录写在前面包 包 ......
Java基础语法（七）——类和对象
rain67的博客
04-24 6099
1.类和对象的初步认识 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。 面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来 面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来 面向对象： 打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。 冰箱就是一个对象，所以只要操作冰箱
java 面向对象三大特性之封装 万字详解（超详细）
Cyan_RA9的博客
01-01 2189
Java 面向对象三大特性之封装，详细讲解了private关键字，this关键字，以及构造器，一文讲透！
Educoder/头歌JAVA实训——JAVA面向对象：类与对象
舟舟的博客
12-07 1万+
Java 是一门面向对象的编程语言，面向对象是 Java 语言的重要特性，所以 Java 面向对象的特性是我们学习 Java 过程中必不可少的环节。 Java 作为一种面向对象语言。支持以下基本概念：多态、继承、封装、抽象、类、对象、实例、方法、重载。 本实训我们主要学习类和对象。
第04章 面向对象（上） 12 代码块
09-12
本章主要探讨的是面向对象编程的基本要素之一——代码块，以及它在Java中的应用。在这个主题中，我们将深入理解代码块的概念，它们的种类，以及如何在实际编程中有效地使用它们。 首先，让我们定义什么是代码块。...
BAT 115个Java面试题和答案——终极（上）
04-04
2. **面向对象编程**：Java是一种面向对象的语言，面试者需要掌握类、对象、封装、继承、多态等核心概念。特别是多态性，它是Java的一个重要特性，理解和运用它可以提高代码的灵活性和可扩展性。 3. **异常处理**：...
个人学习的java笔记——思维导图
01-25
2. **类与对象**：面向对象编程的核心是类和对象。类是对象的模板，定义了对象的属性和行为；对象则是类的实例，具有类所描述的特性并能执行类中定义的操作。 3. **封装、继承和多态**：封装是将数据和操作数据的...
黑马程序员入学Java知识——精华总结.doc
05-09
- **面向对象**：Java强调类和对象，支持封装、继承和多态，便于构建复杂的软件系统。 - **安全性**：Java提供了安全管理机制，防止非法代码破坏系统。 - **跨平台性**：Java的“一次编写，到处运行”（Write ...
配置Java开发环境
Broken_x的博客
07-10 1620
Java开发环境配置
java集合工具类
最新发布
药的博客
07-12 485
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 582
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 314
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
Java面向对象（高级）- 类的成员之四：代码块
11-19
在Java面向对象编程的高级阶段，我们深入探讨了类的成员之一——代码块。代码块是Java中一种特殊的结构，用于在特定条件下执行一段预先定义好的代码。本文将分为三个主要部分来讲解。 一、回顾 1. 类及类的内部成员...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值