JAVASE之类和对象（2）

已于 2024-05-26 15:46:03 修改
阅读量691 收藏 29
点赞数 22
分类专栏： JAVASE 文章标签： java-ee 开发语言
于 2024-05-26 15:42:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_82247031/article/details/139172016
版权

哪怕犯错，也不能什么都不做。

主页：趋早–Step
专栏：JAVASE
gitte:https://gitee.com/good-thg
接上部分，我们继续来学习JAVAEE类和对象。

在这里插入图片描述

引言：
这篇文章接上一篇，后半部分，结束类和对象

目录

一、封装

1、封装的概念

面向对象程序三大特性：封装、继承、多态。
而类和对象截断，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。
比如我们使用的手机，我们可以给手机充电，可以开关机，可以调节手机音量的高低，可以看到手机内的应用，但是我们看不到手机内部的构造，这就是厂商将内部细节封装起来了，我们无法看到。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

2、访问限定符

JAVA中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用，JAVA提供了四种访问操作符：
在这里插入图片描述
当然，我们也是通过代码来学习封装的，我们看下面这个代码：

class Person{
    public String name;
    public int age;
    public void show(){
        System.out.println("姓名：" + name + "   年龄： " + age);
    }
}
public class Text {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "Tom";
        person.age = 12;
        person.show();
    }
}

运行结果如下：
在这里插入图片描述
上面的代码我们已经很熟悉了吧！但是，上面这个代码不够安全，容易被修改，所以，这时候封装的意义就体现出来了，我们将代码进行修改：
在这里插入图片描述
很明显，这个代码已经有错了，因为private修饰了属性和方法，private的权限是同一个包中的同一类，上面代码中不在同一个类，所以就会出错，再来看下面代码：
在这里插入图片描述
我们将它放在同一个类中就不会报错了，我们运行试试：
在这里插入图片描述
这就是运行结果了。
这时候，我们想，如果我们非要在类外面访问，该怎么办呢？
这也是有方法的，我们继续：

class Person{
    private String name;
    private int age;
    public void show(){
        System.out.println("姓名：" + name + "   年龄： " + age);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
public class Text {
    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "Tom";
        //person.age = 12;
        person.setName("Sam");
        person.setAge(15);
        System.out.println(person.getName());
        System.out.println(person.getAge());
    }
}

看代码，我们运行一下试试：
在这里插入图片描述

这个代码就叫做封装。我们可以提供公开的方法进行访问，这就相当于我们的手机充电口，我们可以给手机充电，但是我们不知道他是实现的细节。

注意：

这时候，我们说一个小技巧，我们看到那么多方法，需要一个一个字母敲出来可真的太浪费时间了，为了提供我们的效率，我们就用快捷方式，我们的IDEA功能非常的强大，可以自动帮助我们生成，如何生成呢？让我来告诉你：
我们先把那些方法删除，现在的代码是这样：
在这里插入图片描述
然后就来生成吧！

（1）我们在需要生成代码的地方点击鼠标右键，然后选择下面的Geneate

在这里插入图片描述

（2）然后就会出现下面的界面

在这里插入图片描述

（3）这时候我们选择图片中的选项

在这里插入图片描述

（4）点进来的界面是这样的

在这里插入图片描述

（5）我们按住Ctrl 或者 Shift 键，用鼠标点击需要生成的方法

在这里插入图片描述

（6）最后点击下面的OK，他就会自动生成了。

在这里插入图片描述
我们看结果：
在这里插入图片描述
这就是我们编译器自动生成的方法，是不是和好用的，当然，我在这里写的比较繁琐，我们自己使用的时候完全不会这么麻烦的，同时，我们再告诉大家一个快捷键 Alt + Insert，他也能帮助我们生成上面的方法，至于他怎么使用，大家自己尝试一下就知道了，需要我们自己动手哦。

3、包

（1）概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类手机在一起成为一组。比如我们的一个文件夹，文件夹中的内容就是类，可以帮助我们更好的管理类。
在JAVA中，包是对类、接口等封装机制的体现，是一种类对接口等的很好的组织方式，比如一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的嘞，只要处在不同的包中即可。

（2）导入包中的类

我们使用import语句来导入包

我们看下面的代码：
在这里插入图片描述
这就是导入了包，运行结果如下：
在这里插入图片描述

（3）自定义包

我们如何自定义包呢？下面就来介绍一下：

<1> 选择src并且右键点击

在这里插入图片描述

<2> 选择new

在这里插入图片描述

<3> 选择Package并且点击

在这里插入图片描述

<4> 输入包的名称，这里我输入的是demo2（可以自己定义名字）,然后回车，就创建好了一个包。我们来说一下创建包的基本原则：
1.在文件的最上方加上一个 package 语句指定该代码在哪个包中
2.包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式
3.报名要和代码路径想匹配
4.如果一个类没有package语句，则该类被放到一个默认包中。

在这里插入图片描述

（4）包的访问权限控制举例

我们在demo2中定义一个Date类：
在这里插入图片描述

然后我们在demo1中的Text中进行访问：
在这里插入图片描述

在这里插入图片描述
这样，我们就可以访问不同包中的类了。

二、static成员

1、再谈学生类

public class Student {
    public String name;
    public int age;
    public String gender;
    public double score;

    public Student(String name, int age, String gender, double score) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.score = score;
    }

    public void print(){
        System.out.println(this.name + "今年" + this.age + "岁了，他是一个" + 
                this.gender + "生，这次的考试成绩是" + this.score + "分");
    }

    public static void main(String[] args) {
        Student student1 = new Student("Tom",12,"男",66);
        Student student2 = new Student("XiaoHong",13,"女",76);
        Student student3 = new Student("Sam",12,"男",86);
        student1.print();
        student2.print();
        student3.print();
    }
}

运行结果如下：
在这里插入图片描述
好的，后面的操作我们都是在这个代码上提出问题并且在这个代码上修修改改。
这时候，我们有了第一个问题，假如他们三个人都在同一个班中，那么我们有必要都存一份吗？很明显是没有必要的，所以，这个时候我们的static就出马了。

在JAVA中，被static修饰的成员，称之为静态变量，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

2、static修饰成员变量

static修饰的成员变量，称为静态变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。
静态成员变量特性：
1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。
2.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3.类变量存储在方法区中
4.生命周期伴随类的一生。（随类的加载而加载，随类的卸载而销毁）

在这里插入图片描述

在这里插入图片描述
运行结果如下：
在这里插入图片描述
上面的代码，我们是已经给班级赋值了，如果不赋值会是怎样呢？
我们看代码：
在这里插入图片描述
剩下的不改变，运行一下：
在这里插入图片描述
这里称为了null，至于为什么？咱们可以看看上一篇文章就懂啦！
我们也可以在类外赋值，如何赋值呢？看代码：
在这里插入图片描述
在这里插入图片描述

3、static修饰成员方法

在这里插入图片描述

成员方法同样也是使用类名进行访问的，在JAVA中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。
静态方法特性：
1.不属于某个具体的对象，是类方法
2.可以通过对象调用，也可以通过类名调用，更推荐使用类名调用
3.不能在静态方法中访问任何非静态成员变量
4.静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法调用时候无法传递this引用。

我们用代码说明一下上面的特性3和4
在这里插入图片描述
在这里插入图片描述
这就是本部分的内容啦，但是还没有结束，咱们的思维导图还没有整理完哦。

4、static成员变量初始化

（1）就地初始化

就地初始化就是在定义时就直接给出初始值

在这里插入图片描述

（2）静态代码块初始化

还记得这张图吗？就让我们继续学习吧！
在这里插入图片描述

三、代码块

1、代码块概念以及分类

使用{}定义的一段代码称为代码块，根据代码块定义的位置以及关键字，又可分为以下四种：
1.普通代码块
2.构造块
3.静态块
4.同步代码块

2、普通代码块

定义在方法中的代码块

在这里插入图片描述
运行结果如下：
在这里插入图片描述

3、构造代码块

定义在类中的代码块，也叫实例代码块。构造代码块一般用于初始化实例成员变量。

在这里插入图片描述

4、静态代码块

使用static定义的代码块称为静态代码块，一般用于初始化静态成员变量。

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

拓展：

在这里我们拓展一个点，我们先看代码：

public class Student {
    public String name;
    public int age;
    public static String classes;

    public Student(){
        System.out.println("不带参数的构造方法");
    }
    public Student(String name, int age) {
        System.out.println("带两个参数的构造方法");
        this.name = name;
        this.age = age;
    }

    {
        System.out.println("这是实例代码块/构造块");
    }


    // 类加载的时候就会执行
    static {
        System.out.println("这是静态代码块");
    }

    public void show(){
        System.out.println(this.name + "今年" + this.age + "岁了");
    }

    public static void main(String[] args) {
        Student student = new Student();
    }
}

我们运行一下看结果：
在这里插入图片描述
我们的静态代码块在类加载的时候就会执行了，我们把main方法改成下面这样并且运行试试：
在这里插入图片描述
这就证明了我们上面的答案。
这个时候，我们再看下面的代码：
在这里插入图片描述
我们发现再次实例化的时候，静态代码块就没有再执行了。

这就是因为静态的只会执行一次

注意:
1.静态代码块不管生成多少个对象，其只会执行一次
2.静态成员变量是类的属性，因此是在JVM加载嘞时开辟空间并且初始化的
3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行
4.实例代码块只有在创建对象时才会执行

四、内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。

在JAVA中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类，内部类也是封装的一种体现。

1、内部类的分类

实例内部类
静态内部类
局部内部类
匿名内部类
在这里插入图片描述

2、实例内部类

class Outer{

    public int data1;
    int data2;
    public static int data3;

    public void test(){
        System.out.println("Outer --> test()");
    }
    // 实例内部类 --> 未被static修饰
    class Inner{
        public int data4;
        int data5;

        public void func(){
            System.out.println("Inner --> func()");
        }
    }
}

public class Test {

}

我们已经写好了上面的代码，我们就慢慢来理解实例内部类吧！

如何获取内部类的对象
我们可以把内部类看做一个实例成员，使用外部类的对象来调用

在这里插入图片描述
使用上面的两种方法都是可以的。

注意：
1.外部类中的任何成员变量都可以在内部类方法中直接访问
2.实例内部类所处的位置与外部类成员位置相同，因此也受public,private等访问限定符的约束
3.在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员来访问
4.实例内部类对象必须在先有外部类对象的前提下才能创建
5.实例内部类的非静态方法中包含了一个指向外部类对象的引用
6.外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象

3、静态内部类

class Outer{
    public int data1 = 1;
    int data2 = 2;
    public static int data3 = 3;
    public void test(){
        System.out.println("Outer-->test()");
    }
    static class Inner{
        public int data4 = 4;
        int data5 = 5;
        public static int data6 = 6;
        public void func(){
            System.out.println("Inner-->func()");
        }
    }
}
public class Test {
    public static void main(String[] args) {
        
    }
}

如何获取静态内部类对象

在这里插入图片描述

注意：
1.在静态内部类中只能访问外部类中的静态成员
在这里插入图片描述
当然，如果我们非要访问也是有办法的：
在这里插入图片描述

2.创建静态内部类对象时，不需要先创建外部类对象。

4、局部内部类

定义在外部类的方法体或者{}中，该中内部类只能在其定义的位置使用，使用很少

public class Test {
    public void func(){
        // 局部内部类
        class Inner{
            
        }
    }
    public static void main(String[] args) {
    }
}

在这里插入图片描述

注意：
1.局部内部类只能在所定义的方法体内部使用
2.不能被public,static等修饰
3.编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class
4.几乎不会使用

5、匿名内部类

class Person{
    public String name;
    public int age;
}


public class Test {
    public static void main(String[] args) {
        // 匿名对象 只能使用一次
        new Person();
        System.out.println(new Person().name);
        System.out.println(new Person().age);

        // 匿名内部类
        new Person(){

        };
    }
}

在这里插入图片描述

五、对象的打印

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void print(){
        System.out.println(this.name + "今年" + this.age + "岁了");
    }
}
public class Test {
    public static void main(String[] args) {
        Person person = new Person("Tom",12);
        person.print();
    }
}

运行结果如下：
在这里插入图片描述
我们可以看到，我们每次打印的时候需要调用print方法，当字段很多的时候，我们写print方法的时候会显得函麻烦，这时候我们就需要更简单的方法了。在我们JAVA中就有这样的方法，我们先看下面的代码：
在这里插入图片描述
我们看到红色方框中的是一堆看不懂的东西（它当然是有意义的，我们这里不说他是什么意思），我们想要把它变成打印里面的对象该怎么办呢？

这时候就需要用到我们所说的toString方法了

看代码：

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void print(){
        System.out.println(this.name + "今年" + this.age + "岁了");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Person person = new Person("Tom",12);
        person.print();

        System.out.println(person);
    }
}

运行结果如下：
在这里插入图片描述

我们同样是有快捷键来生成toString方法的,我们看下面的步骤
1.右键 --> Generate
在这里插入图片描述
2.找到toString()点击并选择就可以可以生成啦在这里插入图片描述
在这里插入图片描述
或者使用Alt + Insert ，剩下的步骤是完全一样的。

我们JAVASE之类和对象部分就全部学习完啦，但是我们还需要继续努力，继续加油！！！

趋早——Step
关注
  • 22
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
06_javaSE复习之面向对象准备阶段
04-24
什么是面向对象、如何定义类、如何定义对象、成员变量、局部变量、静态变量、匿名对象、Math.randon()/this/static 代码块(局部代码块、构造代码块、静态代码块、同步代码块) 、java内存结构
5-JavaSE之面向对象编程-类与对象（上）1
08-03
5-JavaSE之面向对象编程-类与对象（上）1
【JavaSE】类和对象
weixin_73060900的博客
02-17 1136
对类和对象进行简单的介绍，其中包括面向对象的编程思想，类和对象的基本内容，成员变量和成员方法的介绍以及对这些内容的内存解析等等。
JavaSE之类和对象
奋斗
11-21 874
JavaSE之类和对象 什么是面向对象？什么是面向过程？⏰ 一件事可能会细化成很多小事，如果是每件小事都要自己去编代码实现，才能够完成整件事，我们可以称之为面向过程。 一件大事可以分为简单的几个模块，通过这几个简单模块的交互（可以理解为合作）就可以完成整件事，此时可以称为面向对象 针对面向对象要干三件事???? 找对象 创建对象 适用对象 对象从何而来？???? 从类而来。类由关键字class修饰，类名统一使用大驼峰。 一个类里包含哪些东西？???? 字段/属性/成员变量（类的内部，方
【JavaSE】JavaSE之类和对象（上）
bit me的博客
09-21 1317
JavaSE之类和对象前半部分知识，庖丁解牛式带你深入学习~~
【JavaSE】JavaSE之类和对象（下）
bit me的博客
09-24 2465
JavaSE类和对象后半部分讲解，让类和对象手到擒来供你使用~~
JavaSE基础语法之类和对象
fear_wolf的博客
09-04 497
Java 作为一门纯面向对象的编程语言，那么我们学习面向对象的思想就是极为重要的，而学习面向对象思想的第一个内容，就是类和对象一、Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情类是用来对一个实体（对象）来进行描述的//创建类field;//字段（属性） 或者 成员变量method;//行为 或者 成员方法}class。
JavaSE-面向对象之类与对象
qq_59737375的博客
04-22 2081
权限控制符] class 类名 {//零个到多个构造器 * 构造器定义 * 注意:构造器无返回值类型[权限控制符] 类名(参数列表){};//零个到多个属性 * 属性定义[权限控制符] [static | final] 属性类型 属性名;//零个到多个方法 * 方法定义[权限控制符] [abstract | final] [static] 返回值类型 方法名(参数表){};提示：定义类的时候，不是必须显式写构造方法、属性、方法。【示例】：定义一个学生类。
javaSE系列之类与对象
zjy521_的博客
03-13 1141
javaSE系列之类与对象
javaSE之类和对象
weixin_30352645的博客
05-26 101
面向过程：自顶向下，逐句而行。 面向对象：程序设计中采用封装、继承、多态等设计方法 转载于:https://www.cnblogs.com/1996h/p/5532941.html
【javaSE】 类和对象详解
m0_71731682的博客
07-29 1356
面相对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是洗衣机计算机并不认识，需要开发人员告诉给计算机什么是洗衣机。上图左侧就是对洗衣机简单的描述，该过程称为对洗衣机对象(实体)进行抽象(对一个复杂事物的重新认知)但是这些简化的抽象结果计算机也不能识别，开发人员可以采用某种面相对象的编程语言来进行描述，比如：Java语言。在java中定义类时需要用到class关键字，具体语法如下// 创建类field;// 字段(属性) 或者 成员变量method;// 行为 或者 成员方法。
JavaSE——【类和对象】
2302_81247414的博客
06-08 1065
面相对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是洗衣机计算机并不认识，需要开发人员告诉给计算机什么是洗衣机上图左侧就是对洗衣机简单的描述，该过程称为对洗衣机对象(实体)进行抽象(对一个复杂事物的重新认知)，但是 这些简化的抽象结果计算机也不能识别，开发人员可以采用某种面相对象的编程语言来进行描述，比如：Java语 言。在java中定义类时需要用到class关键字，具体语法如// 创建类field;// 字段(属性) 或者 成员变量method;// 行为 或者 成员方法。
07_javase面向对象之继承
04-24
关键字super/this的用法和区别;在继承中子类和父类构造方法的关系;方法重写;final关键字
javaSE代码实例
06-21
15.1.2　外部类之内创建内部类对象　322 15.1.3　外部类之外创建内部类对象　323 15.1.4　内部类与外部类之间的成员互访　324 15.1.5　内部类与外部类的预定义对象引用this　327 15.2　局部内部类　328 15.2.1　局部...
JavaSE 之 传统日期格式化的线程问题
12-21
需求：让多线程同时去解析日期 ... //任务类：用于解析成Date对象 Callable task = new Callable() { @Override public Date call() throws Exception { return sdf.parse("20200123")
【javaEE-有关CPU进程和线程实现的并发编程及二者的区别】
2301_76249062的博客
06-13 468
javaEE初阶-线程和进程的区别，及cpu调度执行和操作系统的资源分配
【JavaEE】Spring Boot MyBatis详解(一)
m0_74105656的博客
06-10 432
Mybatis详解(一):包括注解和XML的两种实现方式,以及相关的配置
为什么选择Python作为AI开发语言
AI心易行者
06-09 1907
综上所述，Python因其简洁易读的语法、丰富的库和框架、广泛的社区支持、适合快速原型开发的特性以及良好的兼容性和集成性，成为AI开发的首选语言。而像PlugLink这样的工具，则进一步提升了Python在AI开发中的效率和便利性。对于任何希望在AI领域有所作为的开发者来说，掌握Python无疑是必不可少的技能。在未来，随着AI技术的不断发展和进步，Python必将继续扮演重要角色，推动这一领域的创新和变革。如果你还没有开始学习Python，那么现在就是最好的时机。
国内移动端APP月活跃（MAU）Top5000 数据整理
最新发布
06-16
国内移动端APP月活跃（MAU）Top5000 时间范围：2020年-2022年 具有一定参考价值 csv格式
javase之面向对象
09-07
面向对象是一种编程范式，它将程序设计看作是对象之间的交互。在Java语言中，面向对象编程是一种重要的编程方式。引用中提到了面向对象的特征，包括抽象、封装、继承和多态。抽象指的是将具体的事物抽象成类，类是对象的抽象描述。封装指的是将数据和对数据的操作封装在一起，通过对象的方法来访问数据。继承指的是一个类可以继承另一个类的属性和方法，从而实现代码的复用。多态指的是同一种方法可以具有不同的实现方式，通过方法的重写和重载来实现多态性。引用中提到了类是对象的抽象，而对象是类的实例。例如，一个人可以被看作是人这个类的一个具体对象。引用中还提到了在Java中，所有没有继承的类都会默认继承Java的Object类，所以Java中的所有类都是Object类的子类。综上所述，面向对象是JavaSE中的一个重要概念，它通过类和对象的抽象、封装、继承和多态来实现程序的设计和开发。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值