Java——类和对象超详细总结

最新推荐文章于 2023-03-14 11:21:47 发布
最新推荐文章于 2023-03-14 11:21:47 发布
阅读量2.4k 收藏 85
点赞数 35
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49215278/article/details/121116695
版权

文章目录

类和对象

1.类与对象的初步认识

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

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

面向过程注重的是过程，就像我们用手洗衣服，我们需要先用盆接水，然后放入衣服，然后放入洗衣粉，然后用手搓，然后拧干晒起来。

面向对象注重的是对象，就像我们用洗衣机洗衣服，只要把衣服和洗衣服放入洗衣机，然后晒干就可以了，不用去管洗衣机是如何去洗衣服的。

2.类和类的实例化

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

类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。

声明一个类就是创建一个新的数据类型，而类在Java中属于引用类型，Java使用关键字class来声明类。我们来看以下简单的声明一个类。

基本语法

//创建类
class <class_name>{
    field;    //  成员属性
    method;    //  成员方法
}

//实例化对象
<class_name> <对象名> = new <class_name>();

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中的元素称为：成员属性。类中的函数称为：成员方法。

示例：

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

注意事项

和之前写的方法不同，此处写的方法不带static关键字，我们我们会详细解释static是干什么的。

类的实例化

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

  1. 类只是一个模型一样的东西，限定了类有哪些成员。
  2. 一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储类成员变量。
class Person{
    public int age;    //  成员属性  实例变量
    public String name;
    public String sex;
    public void eat(){    //成员方法
        System.out.println("吃饭！");
    }
    public void sleep(){
        System.out.println("睡觉！");
    }
}

public class DemoTest {
    public static void main(String[] args) {
        Person person = new Person();    //  通过new实例化对象
        Person.eat();    //  成员方法调用需要通过对象的引用调用
        Person.sleep();
        //  产生对象  实例化对象
        Person person2 = new Person();
        Person person3 = new Person();
    }
}

输出结果为：

吃饭！
睡觉！

注意事项

  1. new关键字用于创建一个对象的实例。

  2. 使用.来访问对象中的属性和方法。

  3. 同一个类可以创建多个实例。

3.类的成员

类的成员包含以下：字段、方法、代码块、内部类和接口等。

此处我们重点介绍前三个。

3.1字段/属性/成员变量

在类中，但是方法外部定义的变量。这样的变量我们称为"字段"或"属性"或"成员变量"(三种称呼都可以，一般不会严格区分)，用于描述一个类中包含哪些数据。

class Person{
    public String name;    //  字段
    public int age;
}

public class TestDemo {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

//执行结果
null
0

注意事项

  1. 使用.访问对象的字段。
  2. "访问"既包含读，也包含写。
  3. 对于一个对象的字段如果没有显式设置初始值，那么会被设置一个默认的初值。

默认值规则

对于各种数字类型，默认值为0。

对于boolean类型，默认值为false。

对于引用类型(String,Array,以及自定制类)，默认值为null.

Person person = null;
//这个引用不指向任何的对象

Person person = new Person();
Person person2=person;
//person2这个引用指向person这个引用所指向的对象

Person person = new Person();
person = new Person();
person = new Person();
person = new Person();
//一个引用不可以同时指向多个对象 实际指向的是最后一个对象

字段就地初始化

很多时候我们不希望字段使用默认值，而是需要我们显式设定初值，可以这样写：

class Person{
    public String name = "ljj";    
    public int age = 18;
}

public class TestDemo {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

//执行结果
ljj
18
3.2方法

用于描述一个对象的行为。

class Person{
    public String name = "ljj";    
    public int age = 18;
    
    public void show(){
       System.out.println("我叫"+name+",今年"+age+"岁")； 
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

//执行结果
我叫ljj,今年18岁

此处的show方法，表示Person这个对象具有一个"展示自我"的行为。

这样的show方法是和person实例相关联的，如果创建了其他实例，那么show的行为就会发生变化。

Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person.show();

//执行结果
我叫李四，今年20岁
3.3 static关键字
  1. 修饰属性
  2. 修饰方法
  3. 代码块
  4. 修饰类

a）修饰属性，Java静态属性和类相关，和具体的实例无关。换句话说，同一个类的不同实例共用一个静态属性。

class TestDemo1{
    public int a;
    public static int count;
}

public class TestDemo {
    public static void main(String[] args) {
        TestDemo1 t1 = new TestDemo1();
        t1.a++;
        TestDemo1.count++;
        System.out.println(t1.a);
        System.out.println(TestDemo1.count);
        System.out.println("===============");
        TestDemo1 t2 = new TestDemo1();
        t2.a++;
        TestDemo1.count++;
        System.out.println(t2.a);
        System.out.println(TestDemo1.count);
    }
}

输出结果为：

1
1
===============
1
2

b)修饰方法

如果在任何方法上应用static关键字，此方法称为静态方法。

  1. 静态方法属于类，而不属于类的对象。
  2. 可以直接调用静态方法，而无需创建类的实例。
  3. 静态方法可以访问静态数据成员，并可以更改静态数据成员的值。
class TestDemo1{
    public int a;
    public static int count;
    
    public static void change(){
        count = 100;
        //a = 10;  error  不可以访问非静态数据成员
    }
}

public class TestDemo {
    public static void main(String[] args) {
        TestDemo1.change();    //  无需创建实例对象就可以调用
        System.out.println(TestDemo1.count);
    }
}

输出结果：

100

注意事项1：静态方法和实例无关，而是和类相关。因此导致了两个情况：

  1. 静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的)。
  2. this和super两个关键字不能在静态上下文中使用(this是当前实例的引用，super是当前实例父类实例的引用，也是和当前实例相关)。

注意事项2：

  1. 我们曾经写的方法为了简单，都统一加上了static。但实际上一个方法具体要不要带static，都需要视情形而定。
  2. main方法为static方法。

4.封装

软件开发的本质就是对程序复杂程度的管理，如果一个软件代码复杂程度太高，那么就无法继续维护。如何管理复杂程度？封装就是最基本的方法。

在我们写代码的时候经常会涉及两种角色：类的实现者和类的调用者。

封装的本质就是让类的调用者不必了解类的实现者是如何实现类的，只要知道如何使用就行了。

这样就降低了类使用者的学习和使用成本，从而降低了复杂程度。

4.1 private实现封装

private/public这两个关键字表示"访问权限控制"。

被public修饰的成员变量或者成员方法，可以直接被类的调用者使用。

被private修饰的成员变量或者成员方法，不能被类的调用者使用。

直接使用public

class Person{
    public String name = "ljj";    
    public int age = 18;
    
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("我叫"+person.name+",今年"+person.age+"岁");
    }
}
    
//执行结果
我叫ljj，今年18岁

这样的代码导致类的使用者(main方法的代码)必须要了解Person类内部的实现，才能够使用这个类，学习成本较高。

一旦类的实现者修改了代码(例如把name改成myName)，那么类的使用者就需要大规模的修改自己的代码，维护成本较高。

范例：使用private封装属性，并提供public方法供类的调用者使用。

class Person{
    private String name = "ljj";    
    private int age = 18;
    
    public void show(){
        System.out.println("我叫"+person.name+",今年"+person.age+"岁");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

//执行结果
我叫ljj，今年18岁

此时字段已经使用private来修饰，类的调用者(main方法中)不能直接使用。而需要借助show方法。此时类的使用者就不必了解Person类的实现细节。

同时如果类的实现者修改了字段的名字，类的调用者不需要做出任何修改(类的调用者根本访问不到name,age这样的字段)。

注意事项

  1. private不光能修饰字段，也能修饰方法。
  2. 通常情况下我们会把字段设为private属性，但是方法是否需要设为public，就需要视具体情形而定。一般我们希望一个类只提供"必要的"public方法，而不应该把所有的方法都无脑设为public。
4.2 getter和setter方法

当我们使用private来修饰字段的时候，就无法直接使用这个字段了。

代码示例

class Person{
    private String name = "ljj";    
    private int age = 18;
    
    public void show(){
        System.out.println("我叫"+person.name+",今年"+person.age+"岁");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.age=20
        person.show();
    }
}

//编译出错
java: age可以在Person中访问private

此时如果需要获取或者修改这个private属性，就需要使用getter/setter方法。

代码示例

class Person{
    private String name;    //  实例成员变量    
    private int age;
    
    public void setName(String name){
        //name = name;    //  不能这样写
        this.name = name;    //this引用，表示调用该方法的对象
    }
    public String getName(){
        return name;
    }
    
    public void show(){
        System.out.println("name:"+name+" age:"+age);
    }
}
    
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("ljj");
       String name = person.getName();
        System.out.println(name);
        person.show();
    }
}

//运行结果
ljj
name:ljj age:0

注意事项

getName即为getter方法，表示获取这个成员的值。

setName即为setter方法，表示设置这个成员的值。

当set方法的形参名字和类中的成员属性名字一样的时候，如果不使用this，相当于赋值，this表示当前实例的引用。

不是所有的字段都一定要提供setter/getter方法，而是要根据实际情况决定提供哪种方法。

在IDEA中可以使用alt+insert(或者alt+F12)快速生成setter/getter方法。在VSCode中可以使用鼠标右键菜单->源代码操作中自动生成setter/getter方法。

5.构造方法

5.1基本语法

构造方法是一种特殊方法，使用关键字new实例化新对象时会被自动调用，用于完成初始化操作。

new执行过程

  1. 为对象分配内存空间

  2. 调用对象的构造方法

语法规则

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

注意事项

  1. 如果类中没有提供任何构造函数，那么编译器会默认生成一个不带参数的构造函数。

  2. 若类中定义了构造方法，则默认的无参构造将不再生成。

  3. 构造方法支持重载，规则和普通方法的重载一致。

代码示例

class Person{
    private String name;    //  实例成员变量    
    private int age;
    private String sex;
    //  默认构造函数  构造对象
    public Person(){
        this.name = "ljj";
        this.age = 10;
        this.sex = "男";
    }
    //  带有3个参数的构造函数
    public person(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    
    public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();    //调用不带参数的构造函数  如果程序没有提供会调用不带参数的构造函数
        p1.show();
        Person person2 = new Person("李四",80,"男”);    //调用不带参数的构造函数  
        p2.show();
    }
}

//执行结果
name:ljj age:10 sex:男
name:李四 age:80 sex:男
5.2 this关键字

this表示当前对象引用(注意不是当前对象)，可以借助this来访问对象的字段和方法。

class Person{
    private String name;    //  实例成员变量    
    private int age;
   //  默认构造函数  构造对象
    public Person(){
        //  this调用构造函数
        this("bit",12,"man");    //  必须放在第一行进行显式
    }
    //  这两个构造函数之间的关系为重载
    public person(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();    //  调用不带参数的构造函数
        person.show();
    }
}

//执行结果
name:bit age:12 sex:man

6.认识代码块

字段的初始化方式有：

  1. 就地初始化
  2. 使用构造方法初始化
  3. 使用代码块初始化

前两种方式前面已经学习过了，接下来我们介绍第三种方式，使用代码块初始化。

6.1什么是代码块

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

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

  1. 普通代码块
  2. 构造块
  3. 静态块
  4. 同步代码块
6.2普通代码块

普通代码块：定义在方法中的代码块

public class TestDemo {
    public static void main(String[] args) {
        {
            //  直接使用{}定义普通方法块
            int x = 10;
            System.out.println("x1 = "+x);
        }
        int x = 100;
        System.out.println("x2 = "+x);
    }
}

//执行结果
x1 = 10
x2 = 100
6.3构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Person{
    private String name;    //  实例成员变量    
    private int age;
    private String sex;
    
    public Person(){
        System.out.println("I am Person init()!");
    }
    
    //实例代码块
    {
        this.name = "ljj";
        this.age = 18;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    
     public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();   
        p1.show();
    }
}

//运行结果
I am instance init()!
I am Person init()!
name:ljj age:18 sex:man

注意事项：实例代码块优先于构造函数执行。

6.4静态代码块

使用static定义的代码块，一般用于初始化静态成员属性。

class Person{
    private String name;    //  实例成员变量    
    private int age;
    private String sex;
    private static int count = 0;    //  静态成员变量  由类共享数据  方法区
    
    public Person(){
        System.out.println("I am Person init()!");
    }
    
    //实例代码块
    {
        this.name = "ljj";
        this.age = 18;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    
    //静态代码块
    static{
        count = 10;    //  只能访问静态数据成员
        System.out.println("I am instance init()!");
    }
    
    public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();   
        Person p2 = new Person();    //  静态代码块是否还会被执行？
    }
}

注意事项

  1. 静态代码块不管生成多少个对象，都只会执行一次，且是最先执行的。
  2. 静态代码块执行完毕后，实例代码块(构造块)执行，再然后是构造函数执行。
地火轰雷
关注
java类与对象总结
zhanghongkai0916的博客
10-22 334
类和对象 *理解类与对象 类相当于一个产品的模子，而对象就相当于这个模子具体生产出来的产品，一个模子可以生产无数个产品，一个类也可以生产无数个对象。 类：限定了它所拥有的成员，定义一个类并没有分配实际的内存空间 类的实例化（用new创建对象的实例）：一个类中实例化的对象，占有实际的物理空间，存储类成员变量 //通过类Animal实例化两个对象：dog,cat. class Animal{ ...
Java——TCP/IP超详细总结
用代码征服天下
12-24 2130
网络的基础知识 一、协议 1、简介： 在计算机网络与信息通信领域里，人们经常提及“协议”一词。互联网中常用的具有代表性的协议有IP、TCP、HTTP等。而LAN(局域网)中常用的协议有IPX/SPX”等。 下面通过通俗一点的方式来解释一下协议： 有三个人A、B、C。A只会说汉语、B只会说英语、而C既会说汉语又会说英语。现在A与B要聊天，他们之间该如何沟通呢？若A与C要聊天，又会怎样？这时如果我们...
【类和对象】-----Java篇
weixin_64634186的博客
08-07 1272
1、面向对象的初步认知 1、什么是面向对象 2、面向对象与面向过程 2、类的定义与使用 1、简单认识类 2、类的定义格式 3、类的实例化 1、什么是实例化 2、类和对象的说明 4、this的引用 1、为什么有this引用 2、什么是this引用 3、this引用的特性 5、对象的构造及初始化 1、如何初始化对象 2、构造方法 1、构造方法的概念 2、构造方法的特性 3、默认初始化 4、就地初始化 6、封装 1、什么是封装？ 2、访问限定符 3、封装扩展之包 1、什么是包 2、导入包中的类 3、自定义包 4、
Java类和对象知识点总结
shushuyu_的博客
11-17 668
1.类的初步认识 类就是一类对象的统称。对象就是这一类具体化的一个实例。一个模子可以实例化无数个对象。一个类，可以产生无数的对象。 声明一个类就是创建一个新的数据类型，而类在Java中属于引用类型，Java使用关键字class来声明。 下面是基本语法： class <class_name>{ field;//成员属性/字段/成员变量 method;//成员方法/方法 } <class_name> <对象名> = new <class_nam
Java类跟对象总结:
weixin_52984452的博客
10-28 199
Java类跟对象总结:
java-类与对象总结（下）
雨纷飞_263
04-11 360
一、面向对象三大特性之继承 继承最重要的作用就是实现代码的复用，不但可以使用已有基类所有的功能，而且派生类可以在不改变原有基类的情况下对这些功能进行扩展。 1、继承的实现： 在java 中，继承使用 extends 关键字来实现，定义的语法如下： class [子类] extends [父类] 2、继承的限制： 1）java不允许多重继承，但是允许多层继承 一个子类...
java新手超级入门——类结构篇.docx
最新发布
06-28
### Java新手超级入门——类结构篇 #### 一、Java工程结构 Java程序通常是由多个源文件（`.java`）组成的。这些源文件构成了整个Java工程的基础。在这些源文件中，至少会有一个包含主函数的文件，这个主函数是程序...
Java自学之路——超仔细含练习项目及源码 Java知识体系最强总结————含各个阶段的面试题
08-06
### Java自学之路——超详细含练习项目及源码 #### Java知识体系最强总结 本篇文章旨在根据提供的文件信息，深入解读Java自学之路的关键知识点，并针对其中提到的学习资源进行详细的解析，帮助初学者更好地掌握...
【精品干货】JAVA超全知识点总结——核心面试知识汇总（283页）.pdf
05-30
以下是对标题和描述中提到的Java核心面试知识的详细解释： 1. **JVM（Java虚拟机）** - JVM是Java平台的核心组成部分，它负责执行字节码，并为程序提供运行时环境。Java的“一次编写，到处运行”特性就依赖于JVM的...
Java基础知识总结（超详细整理）
02-02
集合框架是Java处理对象集合的重要工具，包括List、Set和Map接口及其实现类，如ArrayList、HashSet、HashMap等。异常处理机制允许程序在遇到错误时优雅地恢复，而IO流则用于读写文件和进行网络通信。多线程使得程序...
Java中的类和对象总结
12-15
Java中的类和对象总结Java中的类和对象总结
Java类和对象总结
WuJieBest_的博客
10-23 208
Java 类和对象 总结 一、什么是类？ 同类对象的概括。类是抽象的，不具体。 类就是类型。 二、什么是对象 具体事物。万物皆对象；对象是具体的。 三、面向对象的特征有哪些？（面试题） 封装：目的是保护数据。 继承：目的是类的复用。 多态：配合接口实现解耦。 抽象：目的满足软件工程复用原则。 面试题的作答方式：每个特征作用是什么？ 四、编程的模式有哪些？ 面向过程编程（c语言） 面向对象编程（Java C++ Python c#）OOP 面向组件编程（EJB ActiveX COM等） 面向服务
Java类和对象学习总结
Syllll_的博客
12-05 481
Java类和对象学习总结
java类与对象总结(入门）
m0_49057651的博客
07-10 233
一、类与对象的基本概念 类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法） 对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。 可以通过举例很好的理解类与对象的关系，例如学生是一个类，作为学生的我就是一个具体的对象。 类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。 二、java中的类 类的形成意味着这个集合是有共性的，把学生作为一个类的话，
java中的类和对象（重点）超详细
ryy1999的博客
11-04 1306
java中的类和对象 1、类与对象的初步认知 2、类和对象的实例化 3、类的成员 3.1、字段，属性，成员变量 3.2、方法 3.3、static 关键字 3.4、小结 4、封装 4.1、private实现封装 4.2、getter 和 setter方法 5、构造方法 5.1、基本方法 5.2、this 关键字 6、认识代码块 6.1、什么是代码块 6.2、普通代码块 6.3、构造代码块 6.4、静态代码块 7、匿名对象 1、类与对象的初步认知 C语言是面向过程的，关注的是过程，分析出求解问题的步
java对于类和对象知识点的总结
weixin_64874291的博客
03-14 131
首先来说，一个类就相当于是对一个人来进行描述，这个人可以有眼睛，鼻子，嘴巴，类名是class关键字来进行修饰的，首先，类中的成员变量和方法分为两种：一种是普通的（也叫非静态的），一种是静态的。上述代码就是定义了一个类，这个类中可以有成员变量，成员变量就相当于对一个人的属性进行抽象：名字，身高，年龄都可以在成员属性（字段）来进行描述，我们把定义在类的内部，方法的外部的字段称为成员变量，是对一个人的属性进行抽象的描述，为什么说是抽象的描述，因为只是定义了这个人有名字，年龄，而没有说这个人具体的年龄是多少。
Java中类和对象的一些总结
bobxbb的博客
11-11 310
1.类 是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）。 比如说，一只小鸟，我们可以把它归为一个类即“鸟类”，而它有翅膀，有羽毛等等便是它的属性，鸣叫，飞翔等便是它的行为。 类的特征：封装，继承，多态。 2. 对象 对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。 对象是具体的东西了，比如说这只小鸟是一只麻雀，有...
Java关于类和对象的一些总结
默的博客
10-03 305
Java中成员属性默认修饰符为default. 举个栗子 : 假如有成员变量name,类型为String,则声明为String name ; 此时该变量的默认权限修饰符就是default. 下附Java成员权限修饰符权限 : private : 只能在当前类中访问 default : 只能在当前类以及同一个包下访问 protected : 除了当前类以及同一个包下访问外,还为不在同一个包下的子类提...
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

地火轰雷

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

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

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

打赏作者

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

抵扣说明：

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

余额充值