从零开始的 Java 学习（三）类和对象的认识

最新推荐文章于 2024-03-28 20:49:27 发布
最新推荐文章于 2024-03-28 20:49:27 发布
阅读量575 收藏 8
点赞数 9
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_xhjk/article/details/121051231
版权

类和对象

1、对类和对象的初步认识

什么是类？什么是对象？
简单的来说：
类：相当于一个模板，用来描述和包含一类对象的行为和属性。一个类，可以产生无数的对象。
对象：就是类的一个实例是由模板产生的样本，有行为和属性。比如说一个人是一个对象，他的行为有吃饭、睡觉，打豆豆，而他的属性有姓名、年龄，性别。
在这里插入图片描述
JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
在我们开发时我们要：找对象，建对象，用对象，并维护对象之间的关系，这也是我们学习的重点。
简而言之
面向对象就是用代码(类)来描述客观世界的事物的一种方式. 一个类主要包含一个事物的属性和行为。

2、类和类的实例化

声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。
基本语法

// 创建类
class <class_name>{
    field;//成员属性
    method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();

class，用来定义一个类，class_name表示类的名字，类名的书写格式为大驼峰，在类里面包含了字段（属性，成员变量），也包含了方法（行为）。
示例

class Person {
   public int age;//成员属性 实例变量
   public String name;
   public String sex;
   public void eat() {//成员方法
      System.out.println("吃饭!");
   }
   public void sleep() {
      System.out.println("睡觉!");
   }
}

用类类型创建对象的过程，称为类的实例化

class Person{
    public String name;//成员变量
    public int age;
    public String sex;
    public void eat(){//成员方法
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
public class text {
    public static void main(String[] args) {
         Person person=new Person();//通过new实例化对象
         person.eat();//通过对象的引用来访问普通的成员变量
         person.sleep();
         //产生对象 实例化对象
         Person person1=new Person();
         Person person2=new Person();
    }
}

输出结果为

吃饭
睡觉

3、类的成员

普通成员变量和方法

类中的成员包括成员变量（字段，属性）和成员方法（行为）。

class Person{
    public String name;//成员变量
    public int age;
    public String sex;
    public void eat(){//成员方法
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

注意：如果未赋初值，打印的结果就是变量类型的默认值，例如：

class Person{
    public String name;//
    public int age;
    public String sex;
}
public class text {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);  //结果为null
        System.out.println(person.age);   //结果为0
    }

静态成员变量和方法

普通成员变量通过static关键字的修饰变为静态成员变量。
成员变量被static所修饰，存放在方法区中，所有类共享。且不属于对象。
访问方式为：类名.属性
示例：

class TextDemo{
    public int a;
    public static int count;
}
public class text {
    public static void main(String[] args) {
      TextDemo t1=new TextDemo();
      t1.a++;
      TextDemo.count++;                    //结果
      System.out.println(t1.a);            // 1
      System.out.println(TextDemo.count);  // 1

      TextDemo t2=new TextDemo();
      t2.a++;
      TextDemo.count++;
      System.out.println(t1.a);            // 1
      System.out.println(TextDemo.count);  // 2
    }
}

同理，方法也可以被static修饰

public static void eat(){
        System.out.println("吃饭");
    }

在定义时注意以下几点：

  1. 普通的方法里不能定义静态的成员变量
  2. 普通的方法里可以定义静态的方法
  3. 静态的方法里不能定义普通的成员变量
  4. 静态的方法中不能定义普通的方法

因为static定义的变量是类变量，是属于类的。
方法的调用需要对应的引用，而static的定义可以使类不需要引用直接调用，这就出现了冲突。
拓展：

1.null在java中表示“空引用”，表示不引用任何对象，相当于C语言中的空指针。

Person person=null;

2.表示person2这个引用指向 person1 这个引用所指向的对象，相当于指向同一个对象。

Person person1=new Person();
Person person2=person1;

3.一个引用不可以指向多个对象。

4.引用不一定在栈上，如图示：

class Person{
    public int age;
    public String name;
}
class Text {
    Person person =new Person();
    public static void main(String[] args) {
      Text text=new Text();
    }
}

在这里插入图片描述

4、封装

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

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

当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了。
此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法

class Person{
    private String name;
    private int 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;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class text {
    public static void main(String[] args) {
        Person person =new Person();
        person.setAge(12);
        person.setName("345");
        person.getAge();
        person.getName();
        System.out.println(person);
    }
}

结果为Person{name='345', age=12}

this.代表当前对象的引用。

5、构造方法

基本语法

构造方法:是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作（用来构造对象）。
构造的过程为：

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

语法规则：

  1. 方法名与类名相同
  2. 构造方法没有返回值类型声明
  3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

注意事项：

  1. 如果没有实现任何的构造方法，编译器会帮我们默认生成一个不带参数的构造方法，也就是说一个类至少会有一个构造方法，即使我们没有写。
  2. 如果当前类有其他的构造方法，那么编译器就不会帮我们生成不带参数的构造方法。
  3. 构造方法之间可以构成重载。

在这里插入图片描述

class Person{
    public String name;
    public int age;
    public Person(){   //如果没有写不带参数的构造方法，编译器会默认生成一个，这里是写了
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){   //构造带一个String类型参数的构造方法
        this.name=name;
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){   //构造带一个String类型和一个int类型参数的构造方法
        this.name=name;
        this.age=age;
        System.out.println("带两个参数的构造方法");
    }
}
public class text {
    public static void main(String[] args) {
        Person person =new Person();  //这里其实就是在调用不带参数的构造方法
        Person person1=new Person("123");
        Person person2=new Person("123",456);
    }
}

this关键字

this有三种用法：

 - this.data             调用当前对象的属性
 - this.func()           调用当前对象的方法
 - this()                调用当前对象的其他构造方法

this()调用当前对象的其他构造方法如下所示：

在这里插入图片描述

注意：
this()必须放在第一行，并且只能放在构造方法中。

6、代码块

代码块分为本地代码块、实例代码块、静态代码块，同步代码块。
在这里我们学习的重点是实例和静态代码块。

class Person{
    public String name;
    public int age;
    {
        System.out.println("实例代码块"); //实例代码块
    }

    static{
        System.out.println("静态代码块"); //静态代码块
    }
    public Person(){
        System.out.println("Person()不带参数的构造方法");
    }
}
public class text {
    public static void main(String[] args) {
        Person person =new Person();
        Person person1 =new Person();
    }
}

调用的结果是

静态代码块
实例代码块
Person()不带参数的构造方法
实例代码块
Person()不带参数的构造方法

class Person{
    public String name;
    public int age;
    static int count;
    {
        System.out.println("实例代码块"); //这个就是实例代码块
    }

    static{
        System.out.println("静态代码块"); //静态代码块
    }
    public Person(){
        System.out.println("Person()不带参数的构造方法");
    }
}
public class text {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

结果是：

静态代码块
0

根据上述代码，可以发现静态代码块只会被执行一次而且是最先执行的（在类加载的时候就执行），并且静态代码块不用实例化对象也会被执行。

若果都是静态的前提下，静态代码块与静态变量的执行顺序要看代码定义的顺序（当变量未被初识话的情况下例外）。

class Person{
    public String name;
    public int age;
    public static int count=10;
    static{
        count=99;
    }
}
public class text {
    public static void main(String[] args) {
        System.out.println(Person.count);  // 结果为99
    }
}

7、匿名对象

匿名只是表示没有名字的对象

  • 没有引用的对象称为匿名对象。
  • 匿名对象只能在创建对象时使用。
  • 如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象。
class Person{
    public String name;
    public int age;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
public class text {
    public static void main(String[] args) {
        new Person().eat();
        new Person().sleep();
        Person person1=new Person();
        person1.eat();
        person1.sleep();
    }
}

根据代码可以看出区别，匿名对象相当于一个一次性的对象。

w_xhjk
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
JAVA中对类和对象的认识
dddddrrrzz的博客
10-30 1275
目录一、面向对象二、类和类的实例化2.1类2.2类的实例化2.3类的成员2.3.1 字段/属性/成员变量认识 null2.3.2 方法 (method)2.3.3 static 关键字a.修饰属性b.修饰方法c.代码块d.修饰类三、封装3.1 private实现封装3.2 getter和setter方法四、构造方法this关键字五、代码块匿名对象toString方法 一、面向对象 面向对象（OOP）的程序是由对象组成的,每个对象包含对用户公开的特定功能部分。程序中的很多对象来自标准库，还有一些是自定义的。究
java学习资料-类和对象
06-14
java学习资料—类和对象；java学习资料—类和对象；java学习资料—类和对象java学习资料—类和对象；
Java认识类和对象
jijiangpeng的博客
07-05 220
具有相同特性（数据元素）和行为（功能）的对象的抽象就是类，因此对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象。 让我们来看看人类所具有的一些特征，这些特征包括属性（一些参数、数值）以及方法（一些行为，他能干什么）。 每个人都有身高、体重、年龄、血型等属性，人会劳动、会直立行走、会用自己的头脑去创造工具等方法。人之所以能区别于其他类型的动物，是因为每个人都具有“人”这个群体的属性与方法。...
Java类和对象之对象引用之坐标系中两点距离计算
n9102的博客
03-24 676
是从离散数学中引入的，也是如今正在使用的策略，程序把所有的引用关系看作一张图（DOM 图类似），从一个节点 GC ROOT 开始，寻找对应的引用节点，找到这个节点以后，继续寻找这个节点的引用节点，就如递归思想一般，遍历所有，当所有的引用节点寻找完毕之后，剩余的节点则被认为是没有被引用到的节点，即无用的节点，无用的节点将会被判定为是可回收的对象。如果该对象被其它对象引用，则它的引用计数加 1，如果删除对该对象的引用，那么它的引用计数就减 1，当该对象的引用计数为 0 时，那么该对象就会被回收。
JAVA-自己对类与对象的认识
Mr_zdk的博客
09-21 461
术语： 面向对象编程: OOP, Object-oriented Programming 面向对象设计: OOD, Object-oriented Design Java语言是面向对象的编程语言.C语言是面向过程的编程语言. 什么是类？（class） 通过我们学过的JAVA程序我们表示一个数字，表示一个字还可以表示“是”或“否”吗？ 问：怎么来表示一只狗，表示一个商品，怎么表示一个订单...
java 类和对象
weixin_30791095的博客
04-13 135
1.对象 对象是事物存在的实体，通常又会将对象划分为两个部分，对象的属性和对象的行为 2.类 类就是一类事物的总称，如果将某个事物抽象为对象，那么类就是这个对象的总称 xx类-----实例化------->xx对象 类是封装对象的属性和行为的载体，对象则是类的实例。 3.面向对象程序的特点：封装，继承，多态 封装 封装是面向对象编程的核心思想，将对象的属性和行为封...
类和对象的创建和使用
weixin_59863328的博客
11-14 126
定义属性、方法，创建对象、给对象的属性赋值、对象调用方法
Java从零开始学习
06-17
Java从零开始学习
Java中String类和IO流——学习小结
12-22
1.1String类认识 String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。String类对象创建后是一个常量，有final修饰，不能被修改。字符串重新赋值不是修改，而是生成了一个新的字符串...
Java中的类和对象的理解
Otar
02-26 196
类是构造对象的模板和蓝图。由类构造对象的过程称为创建类的实例。对象中的数据称为实例域。操纵数据的过程称为方法对象的三个主要特征： 对象的行为：可以对对象施加哪些操纵，或可以对对象施加哪些方法 对象的状态：当施加那些方法时，对象如何响应 对象标识：如何辨别具有相同行为与状态的不同对象 类与类之间的关系常见的关系 依赖(“uses-a”) ：如果一个类的方法操作另一个类的对象，我们就
Java——类和对象
m0_58764878的博客
01-21 198
一、类和对象的初步认识 首先，类和对象是非常抽象的概念。我们要初步认识一下，什么是类？什么是对象？ a.类就是一类对象的统称。 b.对象就是这一类具体化的一个实例。 我来形象的给大家举几个例子： 相信大家都吃过炒菜，那我们的菜谱就是一个类，而通过这个菜谱就可以做出一道菜，那么在这个例子中，类就是哪个菜谱，而做出来的菜就是那个对象，所以菜就是一个实体，一个菜谱可以实例化出无数个对象。又或者说 ，类就相当于一张房子的图纸， 我们根据这张图纸造出的房子就是具体的对象，而一张图纸 可以造多个房子，所以一...
Java中类和对象的学习
关启培的博客
07-11 452
类的目的：       抽取出一类事物共有的属性和行为，并用一定的语法格式来描述所抽象出的属性和行为。抽象的关键是抓住事物的两个方面：属性和行为。类体：1、变量的声明：用来存储属性的值(体现对象的属性)。 数据           2、方法定义：方法可以对类中声明的变量进行操作，即给出算法(体现对象所具有的行为)。类是具有相同数据结构（属性）和相同操作功能（行为）的对象的集合，对象的共性抽象为类，...
学习 Java类和对象——对象引用
weixin_45342302的博客
04-05 1270
为了完成本次任务，我们需要掌握： 对象的引用和对象； 对象的比较； 垃圾收集机制。 实战1.坐标系中两点距离计算 已知两个点 A、B 以及坐标分别为(2,3) 、(8,-5) ，求 A 和 B 两点之间的距离。 两点间的距离计算公式：设两个点A、B以及坐标分别为(x1,y1)、(x2,y2)，则A和B两点之间的距离为：∣AB∣ /** * 任务：已知两个点 A、B 以及坐标分别为(2,3) 、(8,-5) ，求 A 和 B 两点之间的距离。 * 类名为：Distance */ publi
学习-Java类和对象之对象引用之坐标系中两点距离计算
最新发布
千浔的博客
03-28 631
是从离散数学中引入的，也是如今正在使用的策略，程序把所有的引用关系看作一张图（DOM 图类似），从一个节点 GC ROOT 开始，寻找对应的引用节点，找到这个节点以后，继续寻找这个节点的引用节点，就如递归思想一般，遍历所有，当所有的引用节点寻找完毕之后，剩余的节点则被认为是没有被引用到的节点，即无用的节点，无用的节点将会被判定为是可回收的对象。如果该对象被其它对象引用，则它的引用计数加 1，如果删除对该对象的引用，那么它的引用计数就减 1，当该对象的引用计数为 0 时，那么该对象就会被回收。
java编程-计算两个坐标点之间的距离
weixin_45933223的博客
11-06 6612
•两个私有成员变量x和y表示坐标值； •成员变量x和y的访问器和修改器 •无参构造方法创建点（0，0）； •一个有参构造方法，根据参数指定坐标创建一个点； •distance方法（static修饰）返回参数为MyPoint类型的两个点对象之间的距离 编写主类Test，在主类中输入两点坐标，创建两个点对象，利用distance()方法计算这两个点之间的距离。
Java类和对象 详解（一）
热门推荐
wei_zhi的博客
10-06 18万+
一、面向对象简述面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实
JAVA学习之类与对象例题分享（两点确定直线并进行相关操作）
顾小豆的博客
11-27 1706
最近在自学JAVA，学到类与对象章节，分享一个自我感觉还可以的例题答案，自己编写的，发出来希望大神们知道一二。 源程序如下： package Line_Test; public class Line_Test { public static void main(String[] args) { // TODO Auto-generated method stub // 线段测...
java计算两点之间的距离的两种方法
刀刀宅
09-26 2万+
java关于二维坐标的问题
Java、面向对象，练习题两点之间距离，静态方法，匿名内部类
CN_Orange_的博客
04-08 1139
题目要求 编写一个程序，设计一个点类Point，实例化两个点之后，能调用其方法求两点之间的距离。 Point package com.newedu.javabase.homework.exrecises.topic6; /** * 点--类 * @author giantPanda * */ public class Point { private double x ; private...
java从零开始学习
09-17
首先，可以从学习Java的基础知识开始，如变量、数据类型、运算符、流程控制语句和面向对象等。可以选择一本适合初学者的Java教材，系统地学习基础知识，并进行练习和实践，加深对概念和语法的理解。 其次，要掌握...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

w_xhjk

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

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

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

打赏作者

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

抵扣说明：

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

余额充值