java基础-类和对象详解

已于 2023-07-22 10:31:27 修改
阅读量2.9k 收藏 35
点赞数 20
分类专栏： Java 文章标签： java
于 2021-05-01 18:11:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53946852/article/details/116243289
版权

文章目录

一、类与对象的初步认知

1.面向过程和面向对象

在了解类和对象之前我们先了解一下什么是面向过程和面向对象。

面向过程编程：

C语言就是面向过程编程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

面向对象编程：

JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

来举个例子，就比如洗衣服：
在这里插入图片描述

面向过程：1.拿桶 2.把衣服放桶里 3.接水 4.放洗衣服 5.搓 6.再接水 7.把衣服拧干 8.晒衣服
面向对象：1.把衣服和洗衣粉放进洗衣机 2.打开洗衣机 3.把衣服拿出来晾干

在这里洗衣机就是一个对象，所以只要操作洗衣机所具备的功能，都要定义在对象中。

(1) 面向过程和面向对象的区别

面向过程：注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象：注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来

2.类和对象

类：类就是一类对象的统称
对象：对象就是这一类具体化的一个实例

这样说可能太过于抽象
上面说了java是面向对像编程，如果我们先要找对象编程，首先就得找对象而对象是通过类产生的。
我们来举个通俗易懂的例子：
就比如建房子，类就相当于一个模板也就是图纸
在这里插入图片描述
而对象就是房子，也就是一个实体。只有通过图纸才能建房子。
在这里插入图片描述
所以只有通过类才能产生对象，我们以后开发其实就是：
找对象，建对象，用对象，并维护对象之间的关系。

二、类和类的实例化

1.类的定义

在java当中我们用 class 关键字来创建一个新的类型，我们把它叫做类。
一个类是由方法和字段组成
这里我来举一个例子，我用class定义了一个 People 类，来描述一个人。

class People{
    //成员变量/字段/属性
    public String name ;
    public String sex;
    public int age;

    //成员方法/行为
    public void show(){
        System.out.println("姓名："+name+"性别："+sex+"年龄："+age);
    }
}

class为定义类的关键字，People是类的名字，{}中为类的主体。
类中的元素称为：成员变量也就字段或者叫做成员属性。 这里面的name、age、sex 都是字段。
类中的方法称为：成员方法

字段(成员变量)：定义在类的内部，方法的外部

2.实例化一个类

用类类型创建对象的过程，称为类的实例化
我们已经知道通过class关键字来定义一个类了，而我们知道类只是相当于一个模板，所以我们要通过类来实例化对象，由类产生对象的过程叫做 实例化一个对象。

代码如下（示例）：

class People{//类名大驼峰
    //成员变量/字段/属性
    public String name ;
    public String sex;
    public int age;

    //成员方法/行为
    public void show(){
        System.out.println("姓名："+name+"性别："+sex+"年龄："+age);
    }
}
 
public class Test {
    public static void main(String[] args) {
        People p1 = new People();//示例化一个对象
    }
}

我们通过 new 关键字来实例化一个对象
在这里插入图片描述
一个类是可以实例化多个对象的，就比如我上面那个例子一个图纸是不是可以建很多房子。
在这里插入图片描述
在这里插入图片描述
通过 new 关键字我们是可以实例化多个对象的

public static void main(String[] args) {
        People p1 = new People();
        People p2 = new People();
        People p3 = new People();
}

3.类在内存中的存储

我们知道了如何定义类和通过类实例化对象，那么一个类在内存到底是如何存储的呢？

和数组一样类也属于于引用，而引用指向的是一个对象，p1和p2这些变量都是局部变量它们属于引用，我在前面数组的博客也讲到过局部变量是在栈上开辟内存的，引用里面存的是对象的地址，这些变量里存的都是引用每实例化一个对象就在堆区开辟一块内存。对象里面存的就是字段。

注意：类里面的方法并不是是存在堆区的 ，方法本身是不占内存的，方法是存在方法区里的方法表中，在每个对象 new 好之后前面有几个字节存的就是方法表的地址，只有在调用这个方法时，会通过方法表的地址找到这个这个方法，然后在栈上为这个方法开辟栈帧。当然这里只是简单介绍一下，到后面的博客中会详细讲解。
在这里插入图片描述

引用不一定是在栈上的！如果它是一个示例成员变量，那么它就是在堆上的，就比如这里的 name和 sex。

4.访问类的成员

我们知道了如何定义个和实例化一个对象，那么怎么访问这些成员变量呢？

成员变量的访问：对象的引用 . 属性名
成员方法的访问：对象的引用 . 方法名

class People{
    //成员变量/字段/属性
    public String name ;
    public String sex;
    public int age;
    //成员方法/行为
    public void show(){
        System.out.println("姓名："+name+"性别："+sex+"年龄："+age);
    }
}
public class Test {
    public static void main(String[] args) {
        People p1 = new People();
        System.out.println(p1.name);
        System.out.println(p1.sex);
        System.out.println(p1.age);
        p1.show();
    }
}

运行结果

在这里插入图片描述

注意：这里的成员变量并没有初始化，不同于局部变量不初始化会报错。成员变量不初始化是其类型对应的0值。

在这里插入图片描述

三、类的成员

1.成员变量的初始化

我们把定义在类的内部，方法的外部的变量叫“字段”或者叫它成员变量有时候也叫它“属性"。这三种叫法并没有严格区分。

public static void main(String[] args) {
        People p1 = new People();
        p1.name = "java";
        p1.sex = "nan";
        p1.age = 50;
        p1.show();
    }
}

运行结果
在这里插入图片描述
还有一种就是在定义成员变量的时候赋值，但并不建议这样写，因为在实例化后还是能初始化，没必要多此一举。而且这个类是一个模板，把模板初始化也是不合适的。

class People{
    //成员变量/字段/属性
    public String name = "zhangsan" ;
    public String sex = "lisi";
    public int age = 22;
    //成员方法/行为
    public void show(){
        System.out.println("姓名："+name+"性别："+sex+"年龄："+age);
    }
}

再来看一个代码，这个代码是什么意思呢？

public static void main(String[] args) {
        People p1 = new People();
        People p2 = p1;
}

在这里插入图片描述

这段代码的意思是 p2这个引用，引用了p1指向的这个对象

还有一个问题，一个类可以同时指向多个对象吗？

public static void main(String[] args) {
        People p = new People();
        p = new People();
        p = new People();
}

答案是不能，这里的p只会指向最后一个对象，前面的都被覆盖掉了。

所以一个引用只能同时指向一个对象

2.方法

就是我们曾经讲过的方法，用于描述一个对象的行为.

上面我们已经介绍过了，这里就是一个显示人的信息的方法。
这样的 show 方法是和 p 实例相关联的. 如果创建了其他实例, 那么 show 的行为就会发生变化

class People{
    //成员变量/字段/属性
    public String name ;
    public String sex;
    public int age;
    //成员方法/行为
    public void show(){
        System.out.println("姓名："+name+"性别："+sex+"年龄："+age);
    }
    public void prt(){
        System.out.println("爱java");
    }
}
public class Test {
    public static void main(String[] args) {
        People p1 = new People();
        p1.show();
        p1.prt();
    }
}

运行结果

在这里插入图片描述

成员方法也是通过 对象访问的！

3.toString方法

我们刚刚注意到，我们在把对象的属性进行打印的时候，都自己实现了show函数，其实，我们大可不必。
接下来我们看一段代码：


class People{
    //成员变量/字段/属性
    public String name ;
    public String sex;
    public int age;
    //成员方法/行为
    public void show(){
        System.out.println("姓名："+name+"性别："+sex+"年龄："+age);
    }
}
public class Test {
    public static void main(String[] args) {
        People p1 = new People();
        System.out.println(p1);
    }
}

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

我们发现这里打印的是一个地址，这里在打印的时候会默认调用Object 的 toString 方法来打印

在这里插入图片描述
默认调用Object 的 toString 方法，但是当前类如果重新实现 toString 这个方法后,就会调用当前类重新写的这个toString方法来打印。

IDEA快速生成Object的toString方法快捷键：alt+insert

在这里插入图片描述
再来看一段从写toString方法后的代码

class People{
    //成员变量/字段/属性
    public String name ;
    public String sex;
    public int age;
    //成员方法/行为
    public void show(){
        System.out.println("姓名："+name+"性别："+sex+"年龄："+age);
    }

    @Override//重写toString
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        People p1 = new People();
        System.out.println(p1);
    }
}

运行结果
在这里插入图片描述
我们发现当我们重写toString方法后打印的就是我们重写的toString方法里的内容。
当然重写里双引号里面的内容是可以修改的

@Override
    public String toString() {
        return "People{" +
                "姓名='" + name + "," +
                ", 性别='" + sex + '\'' +
                ", 年龄=" + age +
                '}';
    }

注意： 所以当我们没有重写toString方法的时候，就会默认调用Object 的 toString 方法来打印

@Override 在 Java 中称为 “注解”, 此处的 @Override 表示下面实现的 toString方法是重写了父类的方法.

(1)序列化和反序列化

序列化：把一个对象变成字符串
反序列化：把字符串变成对像

4.匿名对象

没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象

用法如下

public class Test {
    public static void main(String[] args) {
        new People().name = "李四";
        new People().sex = "男";
        new People().age = 18;
        new People().show();

    }
}

每使用一次就得 new 一次

四、static 关键字

1.静态成员变量

我们成员变量分为 普通成员变量和静态成员变量
普通成员变量也叫做实例得成员变量，静态成员变量也叫做类变量。

我们来看下这段代码，我们用 static 关建键字创建了一个静态成员变量cont，我分别用引用和类名来访问 cont ，发现通过对象来访问得时候编译器给了一个警告。
在这里插入图片描述
运行结果

在这里插入图片描述
运行发现并没有报错，但对于整体的一个规范我们还是建议用 类名来访问静态成员变量。

所以静态成员变量的访问方式为 类名.静态成员变量

(1) 静态成员变量在内存中的存储

来看一个代码：

class People{

    public String name ;
    public int age;//普通成员变量

    public static int cont;//静态成员变量
}
public class Test {
    public static void main(String[] args) {
        People p = new People();
        p.age++;
        People.cont++;
        System.out.println(p.age);
        System.out.println(People.cont);

        People p2 = new People();
        p2.age++;
        People.cont++;
        System.out.println(p.age);
        System.out.println(People.cont);

    }
}

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

我们发现 age和cont的区别就是一个没有被 static修饰，一个被static 修饰，那是不是这cont就是同一个cont呢？
在这里插入图片描述
静态成员变量是存在方法区，所以它的访问是不依赖于对象的。
让我们再来看一个例子

class People{
    public String name ;
    public int age;//普通成员变量
    public static int cont;//静态成员变量
}
public class Test {
    public static void main(String[] args) {
        People.cont++;
        System.out.println(People.cont);
    }
}

运行结果
在这里插入图片描述
和普通成员变量不同的是这里我们并没有实例化一个对象，直接通过类名来访问了cont，而普通成员变量不实例化是会报错的。
同样来看这个例子，这段代码运行会报错吗？

class People{
    public String name ;
    public int age;//普通成员变量
    public static int cont;//静态成员变量
}
public class Test {
    public static void main(String[] args) {
        People p = null;
        System.out.println(p.cont);
    }
}

运行结果
在这里插入图片描述
这是为什么呢？我们前面说过 null.任何东西都会出现空引用异常，那这里为什么没有呢？
这里的 p代表p不指向任何对象，而我们已经说过静态成员变量的访问时不依赖于对象的，所以这里并没有发生异常。但如果通过 p访问普通成员变量的话就会报错。
总结：

1.静态成员变量的访问方式是 类名.静态成员变量
2.静态成员变量是不依赖于对象的。

2.静态成员方法

成员方法也分为两种，一种是普通的成员方法，一种是静态的成员方法。
普通的成员方法又叫做实例的成员方法，静态的成员方法也叫做类方法。

通过 static 关键字来创建静态成员方法，且也是通过 类名来访问的

class People{
    public String name ;
    public int age;//普通成员变量
    public static int cont;//静态成员变量

    public static void prt(){
        System.out.println("这是一个静态的成员方法");
    }
}
public class Test {
    public static void main(String[] args) {
        People.prt();

    }
}

运行结果：
在这里插入图片描述
再来看一个例子：
为什么在普通成员方法里访问普通成员变量不报错，而在静态成员方法就报错呢？
在这里插入图片描述

因为静态的成员方法是通过类名来调用的，此时并没有示例化一个对象，我们知道普通的成员变量必须实例化对象后才能使用。
而在普通的成员方法里就可以访问是因为如果想调用普通成员方法就必须实例化对象，实例化对象后这里的 age和name都产生了，所以可以访问

同理可推到出，在静态的成员方法内部也是不可以调用普通成员方法的
在这里插入图片描述

所以在静态的成员方法内是不可以访问普通的成员变量的，也不能调用普通成员方法
注意：我们曾经写的方法为了简单, 都统一加上了 static. 但实际上一个方法具体要不要带 static, 都需要是情形而定.
静态的在类加载的时候就已经定义好了，具体在后面的JVM中会讲解到。

再来看一个final修饰的成员变量，这里的存储和final没关系，主要还是看static修饰。
在这里插入图片描述

五、封装

OOP 语言：面向对象编程，有一些重要的特征：继承 封装 多态
封装：在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.
这样就降低了类使用者的学习和使用成本,从而降低了复杂程度，也保证了代码的安全性

举个例子：
我把类里的name和age都改一下

class People{
    public String name ;
    public int age;//普通成员变量
    public static int cont;//静态成员变量

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        People p = new People();
        p.name = "张三";
        p.age = 18;

    }
}

那类的调用者调用这个类的时候发现这个类被修改，那么它就要大量修改代码。所以 这样的代码非常不安全。
在这里插入图片描述
为了避免这样的情况就得使用封装

1.private实现封装

private/ public 这两个关键字表示 “访问权限控制” .

被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法,不能被类的调用者使用

这里我用private修饰了name，它只能在当前类里使用
在这里插入图片描述

2. getter和setter方法

当我们用private修饰字段后，这个字段就无法被直接使用了。
这个时候就用到了 get 和 set 方法了

class People{
    private String name ;
    private int age;//普通成员变量
    public static int cont;//静态成员变量

    public void setName(String myName){
        name = myName;
    }
    public String getName(){
        return name;
    }
    public  void setAge(int myAge){
        age = myAge;
    }
    public int getAge(){
        return age;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        People p = new People();
        p.setName("小明");//设置成员变量
        System.out.println(p.getName());//获取成员变量
        p.setAge(19);
        System.out.println(p.getAge());
        System.out.println(p);
    }
}

getName 即为 getter 方法, 表示获取这个成员的值.
setName 即为 setter 方法, 表示设置这个成员的值
不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法.

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

总结：封装其实就是将一些需要的字段或者方法，使用private关键字进行修饰，同时提供对应的get和set方法提供给外部

(1) 在 IDEA中快速生成 get 和 set 方法

Alt+Insert 键
在这里插入图片描述

五、构造方法

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作
构造方法没有返回值，且方法名和类名是相同的
构造方法是用来构造对象的(实例化对象)

new 执行过程

1.为对象分配内存空间

2.调用合适的构造方法

1.构造方法的基本使用

class People{
    private String name ;
    private int age;//普通成员变量
    public static int cont;//静态成员变量

    public People(){
        System.out.println("这是一个不带有参数的构造方法");
    }

}
public class Test {
    public static void main(String[] args) {
       People p = new People();
    }
}

运行结果：

在这里插入图片描述

那么为什么我们前面示例化对象时为什么没有构造方法呢？

如果我们没有写构造方法，系统默认会有一个没有参数且没有任何内容的构造方法

在这里插入图片描述

2.构造方法的重载

构造方法和方法一样是可以实现重载的，前面的博客中我们也讲到过重载

重载：

1.方法名要相同
2.参数列表不同（类型和个数）
3.返回值不做要求

代码如下：

class People{
    private String name ;
    private int age;//普通成员变量
    public static int cont;//静态成员变量

    public People(){
        System.out.println("这是一个不带参的构造方法");
    }
    public People(String name){
        System.out.println("这是一个带有一个参数的构造方法");
    }
    public  People(String name,String sex){
        System.out.println("这是一个带有两个参数的构造方法");
    }

}
public class Test {
    public static void main(String[] args) {
       People p = new People();
       People p1 = new People("张三");
       People p2 = new People("李四","男");
    }
}

运行结果：

在这里插入图片描述

3.this关键字

this的三种用法：

1.this.data （访问当前对象的成员变量）
2.this.func() （访问当前对象的成员方法）
3.this.() （访问当前对象自己的构造方法）

在前面说封装的时候我们讲到 get 和 set 方法，当我们自己写构造方法的时候和编译器生成的构造方法有一个不一样的地方。
在这里插入图片描述
来看一段代码：
我们把形参的名字改成了name

class People{
    private String name ;
    private int age;//普通成员变量

    public void setName(String name){
        name = name;
    }
    public String getName(){
        return name;
    }
    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
       People p = new People();
       p.setName("张三");
        System.out.println(p.getName());
    }
}

运行结果：
这是为什么呢？这里传过去的明明是张三
其实这里是局部变量优先了，相当于自己给自己赋值。
在这里插入图片描述
我们只需要加一个 this

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

运行结果
在这里插入图片描述
有的书上说 this 代表当前对象，其实这样的说法并不准确。
正确的说法应该是：this表示当前对象引用
注意：

1.this 是不可以访问静态的成员变量的
2.同样的静态方法的内部也是不能使用 this 的
3.我们以后要习惯使用 this ，避免出现上面的那种情况发生

同样 this 也可以访问成员方法

class People{
    private String name ;
    private int age;//普通成员变量

    public void show(){
        System.out.println("调用了这个方法");
    }
    public void setName(String name){
        this.name = name;
        this.show();
    }
    public String getName(){
        return name;
    }
    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}
public class Test {
    public static void main(String[] args) {
       People p = new People();
       p.setName("张三");
        System.out.println(p.getName());
        
    }
}

运行结果：
在这里插入图片描述
最后就是通过 this（）访问当前对象自己的构造方法

1.只能在构造方法内使用

2.只能使用一个this（）

3.只能放在构造方法的第一行

代码如下：

class People{
    private String name ;
    private int age;//普通成员变量

    public void show(){
        System.out.println("调用了这个方法");
    }
    People(){
        this("张三",18);
        System.out.println("没有参数的构造方法");
    }
    People(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("带有两个参数的构造方法");
    }
    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

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

六、代码块

1.本地代码块

方法内部的代码块，没什么意义了解即可。

2.静态代码块

创建静态代码块

static{
        System.out.println("这是一个静态代码块");
}

注意：静态代码块只执行一次

class People{
    private String name ;
    private int age;//普通成员变量
    People(){
        System.out.println("没有参数的构造方法");
    }

    static{
        System.out.println("这是一个静态代码块");
    }
    {
        System.out.println("这是一个实例代码块");
    }

}
public class Test {
    public static void main(String[] args) {
       People p = new People();
        System.out.println("--------------");
        People p2 = new People();
    }
}

运行结果：
这里可以看到静态代码块只会执行一次

在这里插入图片描述

注意：在静态代码块里也是一样的，不可以使用非静态的数据

。

3.实例代码块

实例代码块也叫构造代码块，在示例代码块中可以对属性进行赋值

class People{
    private String name ;
    private int age;//普通成员变量
    private static int cont;//静态成员变量  
    {
       	this.name = "java";
        this.age = 66;
        cont = 100;
        System.out.println("这是一个实例代码块");
    }

}

4.执行顺序

如果静态代码块、示例代码块和构造方法同时存在，它们的执行顺序是什么呢？

1.静态代码块—>2.实例代码块—>3.构造方法

来看例子：

class People{
    private String name ;
    private int age;//普通成员变量
    private static int cont;
    People(){
        System.out.println("没有参数的构造方法");
    }

    static{
        System.out.println("这是一个静态代码块");
    }
    {
        System.out.println("这是一个实例代码块");
    }

}
public class Test {
    public static void main(String[] args) {
       People p = new People();
    }
}

执行结果：

在这里插入图片描述
我们再来看一种情况：
我们知道 静态代码块是最先执行的，那我在定义静态成员变量的时候同时赋值。

class People{

    private static int cont = 100;
    static{
        System.out.println("这是一个静态代码块");
    }

    public static int getCont() {
        return cont;
    }

    public static void setCont(int cont) {
        People.cont = cont;
    }
    static{
        cont = 888;
        System.out.println("这是第二个一个静态代码块");
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println(People.getCont());
    }
}

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

我们再把静态代码交换顺序

class People{
    static{
        cont = 888;
        System.out.println("这是第二个一个静态代码块");
    }
    private static int cont = 100;
    static{
        System.out.println("这是一个静态代码块");
    }

    public static int getCont() {
        return cont;
    }

    public static void setCont(int cont) {
        People.cont = cont;
    }

}
public class Test {
    public static void main(String[] args) {
        System.out.println(People.getCont());
    }
}

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

所以静态代码块是根据我们书写代码的顺序进行执行的,
注意：我们这里并没有 new 对象，可以知道静态代码块是在类加载的时候就已经执行了

总结

1.一个类可以实例化多个对象
2.所有静态有关的都是不依赖于对象的
3.和静态有关的方法或者是代码块里不能出现普通成员变量
4.IDEA Alt+Insert 可以生成toString方法和 get set方法

完！

爱敲代码的三毛
关注
  • 20
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Java类与对象详细讲解（上）
qq_73471456的博客
11-12 457
Java类与对象详细讲解（上）-----关于什么是面向对象，什么是类
【Java】类和对象详解
qq_61635026的博客
06-15 6409
面向对象（Object-oriented）是一种程序设计的方法和编程范式，它以对象作为程序的基本单位，通过封装、继承、多态等概念来组织和实现程序逻辑。面向对象的编程思想强调将问题分解为对象的集合，每个对象具有自己的状态（属性）和行为（方法），并通过相互之间的消息传递来实现协助和交互。类（Class）是用来对一个实体（对象）进行描述的，主要包括实体（对象）的属性和行为的描述。在Java语言中，类是面向对象编程的基本组织单位，它是对象的模版或者蓝图，描述了对象的属性和行为。
Java——类与对象
最新发布
2303_80472275的博客
05-11 804
Java是一门纯面向对象的语言，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。1.2 面向对象与面向过程常说C语言是面向过程，Java是面向对象。那什么是面向对象，什么是面向过程呢？简单举个例子，现在我要将一个大象装入冰箱里。如何思考这个问题那么大部分情况下，首先想到的就是，怎么打开冰箱门，怎么装进去，怎么又关上冰箱门。
java类与对象（超详细！）
weixin_51976923的博客
10-27 2614
java笔记之类与对象，超详细！必读好文！
Java中的类和对象
qq_62042780的博客
10-08 901
Java中的类和对象
类和对象的基本概念
2201_75897538的博客
05-09 1752
类的组成是由属性和行为两部分组成属性：在类中通过成员变量来体现（类中方法外的变量）行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）类的定义步骤：①定义类②编写类的成员变量③编写类的成员方法public class 类名 {// 成员变量变量1的数据类型 变量1；变量2的数据类型 变量2;// 成员方法方法1;方法2;
JAVA中的类和对象
qq_57146327的博客
03-04 883
this引用指向当前对象成员方法运行时调用该成员方法的对象，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。this引用的是调用成员方法的对象。
Java类与对象详解PPT课件.pptx
11-23
Java类与对象详解是Java编程语言的基础知识，本节将详细介绍Java类和对象的定义、实例化、成员变量、构造方法、访问修饰符、继承等知识点。 一、Java类的定义和实例化 在Java中，类是创建对象的模板，类必须先...
Java中的对象和引用详解
08-30
"Java中的对象和引用详解" Java中的对象和引用详解是Java编程语言中两个非常重要的概念，它们之间有着紧密的联系，但同时也存在着明显的区别。为了帮助大家更好地理解对象和对象引用之间的关系，我们将从对象和对象...
Java开发基础日期类代码详解
08-29
Java开发基础日期类代码详解 Java开发基础日期类代码详解主要介绍了Java开发基础日期类的相关内容，代码通过日期工具类获取指定月份的星期与日期对应关系，以及获取指定月份的所有日期与星期集合等，具有一定参考...
JAVA中的引用与对象详解
08-31
在Java编程语言中，引用和对象是两个关键概念，它们之间的关系和理解对于编写高效、内存管理良好的程序至关重要。引用可以被比喻为遥控器，它用来操控或访问内存中的对象，而对象则像电视机，是实际存储数据和执行...
java面向对象
11-02
JavaSE进阶　JavaSE面向对象入门资料：面向对象 , 异常 , 数组 , 常用类 , 集合 , IO流, 线程, 反射 。
详解Java基础篇--面向对象1(构造方法,static、this关键字)
08-26
本文主要介绍了Java基础篇--面向对象1(构造方法,static、this关键字)，通过示例代码对面向对象、构造方法、static关键字和this关键字进行了详细的解释，对大家的学习或者工作具有一定的参考学习价值。 面向对象编程...
类和对象（上）
ZY_20181010的博客
08-11 314
一、类与对象的初步认识 1.类是对象的抽象，而对象是类的具体实例。   类是抽象的，不占用内存；而对象是具体的，占用存储空间。 2.面向过程与面向对象 C语言是面向过程的，关注的是过程中的数据与方法。 C++是面向对象的，关注的是对象’的属性与功能。 二、类 1.在C++中，结构体内不仅可以定义变量，也可以定义函数。 struct student { char _name[20...
类与对象总结
m0_51765307的博客
01-15 653
类与对象 1. 概念 （1）类：一组具有相同属性和行为的对象的集合。类是一种模板。 （2）对象：对象是类的具体实例,具体的存在。 2.成员变量 比较方向： 声明（位置 修饰） 作用域 是否初始化 生命周期 存储位置 访问 2.1成员变量 静态（类变量）：静态方法区，对于类的所有对象只有一份，属于公共财产 1. 声明位置 ：类中的方法体外面 2. 作用域：本类中：任何地方都有效。 其他类中：由其访问权限决定的。 3. 生命周期：随着类的加载而产生，类的销毁而销毁。生命周期最长。
Java-类和对象解析（超详细）
weixin_52533007的博客
03-31 1812
本篇文章通过通俗的语言。采用图文并茂，穿插代码的方式，为大家讲解java类和对象的知识点，每一句话都是重点！！
什么是类？什么是对象？类和对象有什么关系？
热门推荐
谦
05-13 11万+
面向对象(Object Oriented,OO)。 起初，“面向对象”是指在程序设计中采用封装、继承、多态等设计方法。现在，面向对象的思想已经涉及到软件开发的各个方面。如，面向对象的分析（OOA，ObjectOriented Analysis），面向对象的设计（OOD，Object Oriented Design）、以及面向对象的编程实现（OOP，Object Oriented Programm
Java类与对象
weixin_59995358的博客
05-05 82
对象不是一个笼统的，类似于“桌子”、“椅子”这种代表一类事物的概念，而是类似于“那张桌子”、“这把椅子”这样的具体的某一个事物。向下转型一般用的不多，举个使用场景：当调用子类里有而父类里没有的方法时，需要将引用通过强制转换的形式转化为指向子类的引用，需要提前用instanceOf方法判断要强制转换的引用是否为指向父类的引用。当子类重写的方法的访问权限是私有时，仅相当于子类重新定义了一个新的方法，与这个访问权限为私有的父类中的方法没有关系。Java提供的为类的成员变量赋初值的专门方法，就是构造方法。
Java类和对象（七千字详解！！！带你彻底理解类和对象）
cool_tao6的博客
09-10 521
Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。class类名类的属性（成员变量）；类的行为（成员方法）；类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法//属性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱敲代码的三毛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值