类和对象---JAVA内功心法

已于 2023-05-01 10:29:14 修改
阅读量82 收藏
点赞数 1
分类专栏： SE基础 文章标签： java jvm 开发语言 Powered by 金山文档
于 2023-03-22 23:42:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64247824/article/details/129480621
版权

类和对象的定义：

类：

在我们Java中具有许多基本数据类型，比如int、char、boolean等等，但如果我们需要描述一个活生生的人，这些基本数据类型显然满足不了我们的需求。

因此，java提供了一个很好的解决方法，就是将一个现实生活中的对象抽象成一个类。类是对一个实物（对象）进行描述的，主要描述这个实物（对象）具有哪些属性。比如说一个学生，如果我们要粗略的了解他，那就需要学号（int id）、姓名（String name）、年龄（int age）、行为（void action）等等。而我们的类就是用来描述像学生这一些对象的。

对象：

面向过程：

面向过程编程就是针对项目逻辑进行编程，强调一步一步进行。结果就是代码之间的耦合度过高，牵一发而动全身。

面向对象：

面向对象则是把面向过程的代码进行抽象，是模块化编程。好处就是模块之间相互独立，可以在原有的代码之上进行继承操作，更加方便，利于使用。

如果说类是一张设计图纸，那么对象就是根据设计图纸创造出来的一个具体的实物。比如说印在纸上的印子（对象）是通过印章（类）印出来的，它两的关系就是类和对象的关系。

例1：定义一个学生类：

public class Student {
    public int id;
    public String name;
    public int age;
    public void action() {
        System.out.println(name + "去学习");
    };
}

例2：创建一个学生类的对象：

public class test {
    public static void main(String[] args) {
        //类名 对象名 = new 类名();
        Student s = new Student();
        //同一个类可以创建多个实例
        Student s2 = new Student();
    }
}

创建完之后你就可以通过对象来做一些事情

public class test {
    public static void main(String[] args) {
        //类名 对象名 = new 类名();
        Student s = new Student();
        s.name = "张三";//给这个学生命名
        s.action();//执行学生的行为
    }
}

新建对象时的一些注意事项：

public class test {
    public static void main(String[] args) {
        //注意事项
        //1.
        Student student1 = new Student();
        Student student2 = new Student();
        student1 = student2;//不能这样指向！这样表示student1的引用指向了student2引用的指向
        //2.
        Student student3 = new Student();
        student3 = new Student();
        student3 = new Student();
        student3 = new Student();
        //这样子也只会指向一个对象
    }
}

this指针:

定义：

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。

this指针只能引用当前对象，不能引用其他对象。

public class Student {
    public int id;
    public String name;
    public int age;
    public void setData (int id, String name, int age) {
        id = id;
        name = name;
        age = age;
    }
}

在以上这种情况下，我们该如何知道id、name、age哪个对应着哪个呢？是成员对象里的还是传参的参数呢？

public class Student {
    public int id;
    public String name;
    public int age;
    public void setData (int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

那么在这时我们加上this指针就可以清楚的了解到前面的变量是属于当前对象的，后面的变量是属于传过来的参数的。

this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收。

public class Student {
    public int id;
    public String name;
    public int age;
    public void setData (Student this, int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

构造方法：

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

在Java中如果你没有重写构造方法，那么Java会自动给你提供一个构造方法。形如

如果你自己写了一个构造方法，那么编译器是不会再给你提供构造方法的。

构造方法是可以重载的。

有参构造：

无参构造：

我们还可以用this()来进行简化：

this()函数必须放在第一行！！

不过this()不能有环

初始化：

有参构造的初始化：

    public static void main(String[] args) {
        Student student = new Student(2, "李四", 20);
        System.out.println(student.id + " "  + student.name + " " + student.age);
    }

无参构造的初始化：

    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.id + " "  + student.name + " " + student.age);
    }

就地初始化：

public class Student {
    public int id = 1;
    public String name = "张三";
    public int age = 19;
    public Student(int id, String name, int age) {
    }

    public Student() {
    }
}

局部变量在使用时必须要先初始化，而成员变量在使用时可以不初始化，因为Java在创建一个成员变量时会做以下事情：

  1. 先查看一下该类有没有被加载过。

  1. 给创建的对象分配空间。

  1. 处理并发安全问题（比如多个线程申请对象，JVM要保证给所有对象分配空间）。

  1. 初始化所分配的空间（给对象的成员对象赋予默认值）。

  1. 设置对象头信息。

  1. 调用构造方法。

封装:

面向对象有三大基础特性：封装、继承、多态。

封装的定义：

封装就是将数据和对数据的一些操作进行有机融合，隐藏对象的属性和实现细节，仅公开一些对外的接口来和对象进行交互。

就像电脑一样，在电脑中，实际工作的是CPU、GPU、硬盘等硬件，然而我们在使用电脑时都是用鼠标、键盘、usb接口来对电脑进行操作。

封装提高了代码的复用性，便于调用者的使用，提高了安全性。

包：

包的定义：

包就是将多个不同的类、接口组合在一起进行组织管理的集合。（类似一个文件夹）

在一个工程中允许存在相同名称的类，只要处在不同的包中即可。

包的导入：

我们可以用import语句来导入包：

import java.util.Scanner;
//需要java.util里的其他类可以这样写：
//import java.util.*;

//不过我们更建议第一行的方法，因为不容易出现歧义
//比如java.util.*和java.sql.*里都含有Date类，此时就会报错

//我们还可以导入包中的静态方法或者静态类
import static java.lang.Math.*;
//此时在使用的时候会更加方便
double x = 30;
double y = 40;
// 静态导入的方式写起来更方便一些.
// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
double result = sqrt(pow(x, 2) + pow(y, 2));

也可以在创建对象或者调用方法的时候导入包

        //创建对象时
        java.util.Scanner sc = new java.util.Scanner(System.in);

        //使用方法时
        int[] arr = {1,2,3,4,5};
        System.out.println(java.util.Arrays.toString(arr));

自定义包：

我们在src中new一个包出来。

一般企业的命名规则是他们的域名倒过来命名的，比如我的域名是demo1.feng.com

那么我命名的时候就可以com.feng.demo1

D:\****\src\com\demo1\feng创建完成我们就得到这样的文件地址

然后我们就可以在包中写我们的类或接口啦。

访问限定符：

访问限定符规定了类或字段的 被访问权限（在类外可以被使用/在类外不可以被使用）。

常用的限定符有以下几种：

static:

定义：

虽然说static是静态的意思，但是它实际上与它的字面意思关系不大。

在类中，被static修饰的成员变量称为类变量，它与类的生命周期一致，在内存中只加载一次，因此只存在一份，它不属于某个对象，是所有对象都可以修改、访问的。

static的作用：

方便我们直接使用类来访问变量或调用方法，不用创建对象。只要类被加载了，就可以通过类名来调用。static可以用来修饰成员方法、成员变量，还可以在类中编写static代码块来优化程序性能。

静态成员变量的特性：

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

  1. 既可以通过对象访问，也可以通过类名访问，不过更加推荐用类名访问。

  1. 类变量存储在方法区中。

  1. 随着类的加载而创建，随着类的卸载而销毁， 生命周期伴随着类的一生。

class Student {
    private String name;
    private int age;
    public static String classroom = "306";//static修饰的成员变量
    //private static String classroom = "306";//private修饰的成员变量
    //不能在类外被直接调用！！
}

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(Student.classroom);//可以用类名直接调用
        
        Student student = new Student();
        System.out.println(student.classroom);//也可以用对象直接调用
        //不过不推荐这种写法，多此一举！
    }
}

静态成员的初始化：

  1. 就地初始化

  1. 静态代码块初始化

  1. 静态方法初始化

    private static String classroom = "306";//就地初始化

    //classroom = "308";编译错误，实例代码块不能初始化静态成员变量

    static {//静态代码块初始化
        classroom = "308";
    }

    public static void setClassroom(String name) {//静态方法初始化
        classroom = name;
    }

静态成员初始化会在类加载的时候进行初始化，也就是程序启动的时候进行初始化。

首次创建类对象、访问类的静态成员（变量或方法）会引发类加载。

顺序优先级：静态成员变量 = 静态代码块 > 非静态成员变量 = 非静态代码块 > 构造函数

静态方法的特性：

  1. 静态方法也叫类方法，而对象方法也称为实例方法或非静态方法。

  1. 静态方法不属于某个具体的对象，是类的属性，是所有对象共享的，不存储在某个对象的空间中。

  1. 既可以通过对象访问，也可以通过类名访问，不过更加推荐用类名访问。

如果我们的静态成员变量被private与static 修饰，

且我们在类外需要获取这个静态成员变量，那我们可以借助静态方法来实现：

class Student {
    private String name;
    private int age;
    private static String classroom = "306";//private、static修饰的成员变量

    public static String getClassroom() {//静态方法
        return classroom;
    }
}

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(Student.getClassroom());//可以用类名直接调用

        Student student = new Student();
        System.out.println(student.getClassroom());//也可以用对象直接调用
        //不过不推荐这种写法，多此一举！
    }
}

3.在静态方法中不能调用非静态的成员变量。

4.静态方法中不能调用非静态方法。

5.静态方法不能重写，无法用来实现多态（下一篇咱们细说）

代码块：

1.普通代码块：

    public void goToClassroom() {
        System.out.println("去上课");
    }//普通代码块：定义在方法里的代码块

2.构造代码块（实例代码块）：

构造代码块只有在创建对象的时候才会执行，每创建一个对象，执行一次。

class Student {
    private String name;
    private int age;

    {
        name = "张三";
        age = 15;
        //classroom = "308";编译错误，实例代码块不能初始化静态成员变量!!
    }//构造代码块：一般用来初始化实例成员变量

}

3.静态代码块：

静态代码块无论创建多少个对象只会执行一次。

class Student {
    private String name;
    private static String classroom = "306";//就地初始化

    static {
        classroom = "308";
        getClassroom();
        //name = "张三";     编译错误：静态代码块不可初始化实例成员变量！！
    }//静态代码块：一般用于初始化静态成员变量，也可以调用静态方法。

    public static String getClassroom() {//静态方法
        return classroom;
    }
}

代码块的执行顺序：

优先静态代码块执行（只执行一次！！），然后到实例化代码块，最后构造函数执行。

class Student {
    private String name;
    private int age;
    private static String classroom;

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

    {
        System.out.println("实例代码块执行");
    }

    public Student() {
        System.out.println("构造函数执行");
    }
}

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

内部类

内部类就是将一个类定义在另一个类或者方法的内部。

1.实例内部类

class A {
    private int a;
    private int b;
    private int c;
    a = 100;//编译错误，不能再变量定义阶段修改变量值！！！
    public class B {//这个B类称为实例内部类
        int c;
        void change() {
            a = 100;
            b = 200;//可以在内部类访问外部类的成员变量
            c = 300;//如果有同名，优先访问自己的（内部类）的成员变量
            this.c = 400;//如果要访问外部类的同名成员变量，要加this
        }

        public B() {
            System.out.println("内部类B的构造函数");
        }
    }

    public A() {
        System.out.println("外部类A的构造函数");
    }
}

public class Demo2 {
    public static void main(String[] args) {
        A.B ab = new A().new B();//实例化内部类
    }
}

构造顺序：先A后B

2.静态内部类

class A {
    private int a;
    static int b;
    private static int c;

    static void outmethod1() {
        
    }

    void outmethod2() {

    }
    
    static class C {//这个C类称为静态内部类
        void method() {
            //outmethod2();编译错误，静态代码块只能访问静态方法
            //a = 100;编译错误，静态代码块只能访问静态成员变量

            b = 200;
            c = 200;//静态代码块能够访问静态成员变量
            outmethod1();//静态代码块能够访问静态成员方法
        }
    }
}

public class Demo2 {
    public static void main(String[] args) {
        A.C ab = new A.C();//创建静态内部类的时候不用先创建外部类
    }
}

3.局部内部类

class A {
    void method() {
        class D {//这个D类称为局部内部类
            //局部内部类不能被public、static等访问限定符修饰
            //局部内部类只能再方法体内部调用
        }
    }

}

对象的打印：

如果不重写toString方法

class Person {
    private String name = "张三";
    private int age = 30;
}


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

打印的是类名+地址

重写toString方法之后就可以打印我们想要看到的信息啦：

class Person {
    private String name = "张三";
    private int age = 30;

    @Override
    public String toString() {//重写toString方法
        return "[" + this.name + ", " + this.age + "]";
    }
}


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

写这种内功心法的博客总是耗费我很多时间，不过基础十分重要！时间花的是值得的，大家要多多加油巩固基础哦。

每个人都是生活里的主角！_哔哩哔哩_bilibili

小枫 ~
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
抽象类与接口 --- Java内功心法
m0_64247824的博客
04-01 74
本篇文章包含抽象类概念、抽象类特性、抽象类的作用、接口的概念、语法规则、接口的使用、接口特性、接口的继承、抽象类与接口的区别，干货满满，不容错过~~
继承与多态 --- Java内功心法
m0_64247824的博客
03-31 143
本篇包括：继承的概念、继承的好处、父类成员的访问、子类构造方法、super与this、super与this的不同点、再谈构造方法、Java中的多种继承方式、final关键字、类的组合、多态的概念、多态的实现条件、重写、应该避免在构造函数里调用重写的方法、向上转型、向下转型、多态的优缺点等内容，干货满满~~
1e-5 java_内功心法 -- java.util.LinkedList<E> (5)
weixin_39792747的博客
02-28 130
写在前面的话：读书破万卷，编码如有神--------------------------------------------------------------------下文主要对java.util.LinkedList的4个查询操作进行介绍，主要内容包括：1、LinkedList常用4个查询操作介绍参考内容：1、JDK源码(1.7)-------------------------------...
String类 超详解！！！ --- Java内功心法
m0_64247824的博客
04-05 83
本篇包含String常用方法、构造方法、String对象的比较、字符串的不可变性、字符串的修改、直接修改String对象的弊端、StringBuilder类/StringBuffer类常用方法、String、StringBuffer、StringBuilder的区别
内功心法 -- Java标记接口
dianzhenluo3164的博客
01-26 121
写在前面的话：读书破万卷，编码如有神--------------------------------------------------------------------这篇博客主要来谈谈"Java标记接口"的相关知识，主要内容包括： 1. 概述 2. Serializable 3. Cloneable 4. RandomAccess --------------------...
架构师内功心法-----手写springv2.0aop
hx1176406648的博客
05-06 172
手写springv2.0aop 简介aop 简介 接上文，aop过程发生在ioc的实例化bean过程中。 主要类如下： 代理相关：AopConfig、AdvisedSupport、AopProxy、DefaultAopProxyFactory、CglibDynamicProxy、JdkDynamicProxy 切面相关：MethodInvocation、JoinPoint、Advice、MethodBeforeAdviceIntercepter、MethodAfterAdviceIntercepter、
Map 和 Set（说明、常用方法） --- Java内功心法
m0_64247824的博客
04-10 346
本篇包含关于Map和Set的说明、常用方法。干货满满，不容错过哦哦~~
java中的标记接口_内功心法 -- Java标记接口
weixin_29025911的博客
02-25 209
写在前面的话：读书破万卷，编码如有神--------------------------------------------------------------------这篇博客主要来谈谈"Java标记接口"的相关知识，主要内容包括：1. 概述2. Serializable3. Cloneable4. RandomAccess-----------------------------------...
架构师内功心法-----七大软件设计原则
hx1176406648的博客
03-12 179
七大软件设计原则Open-Closed Principle 开闭原则Dependence Inversion Principle 依赖倒置原则Simple Responsibility Principle 单一职责原则Interface Segregation Principle 接口隔离原则Law Of Demeter 迪米特法则Liskov Substitution Principle 里氏替换原则Composite&Aggregate Reuse Principle 合成复用原则问题作业参考
一文带你彻底理解Java序列化和反序列化
09-07
Java序列化和反序列化是Java开发中常用的技术，它允许我们将Java对象转换成字节流，以便于存储、在网络中传输或在不同时间点重建对象。这一过程对于实现某些关键功能至关重要，如持久化数据、分布式计算和跨进程通信...
Java程序员必修内功心法！（内功修炼第三层）
LingHu66的博客
12-04 293
Java 核心技术 1.1. 反射机制 JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。 1.1.1.静态编译和动态编译 1，静态编译： 在编译时确定类型，绑定对象 2，动态编译： 运行时确定类型，绑定对象 1.1.2.反射机制优缺点 优点： 运行期类型的判断，动态加载类，提高代码灵活度。 缺点： 1,性能瓶颈：反射相当于一系列解释操作，通知
Java程序员必修内功心法！（内功修炼第一层）
LingHu66的博客
11-30 1083
1. Java 基本功 1.1. Java 入门（基础概念与常识） 1.1.1. Java 语言有哪些特点? 简单易学； 面向对象（封装，继承，多态）； 平台无关性（ Java 虚拟机实现平台无关性）； 可靠性； 安全性； 支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）； 支持网络编程并且很方便（ Java 语言诞生本身就是为简化网络编程设计的，因此 Java 语言不仅支持网络编程而且很方便）； 编译与解释并存；
JAVA11-JVM调优的十个JVM核心知识点，总有你需要的一点
weixin_39521850的博客
12-24 1591
唐僧：龙不是你那么骑的 想要提高程序员自身的内功心法无非就是数据结构跟算法 + 操作系统 + 计网 + 底层，而所有的Java代码都是在JVM上运行的，了解了JVM好处就是： 写出更好更健壮的代码。提高Java的性能，排除问题。面试必问，要对知识有一定对深度。 1、简述JVM 内存模型 从宏观上来说JVM 内存区域 分为三部分线程共享区域、线程私有区域、直接内存区域。 1.1、线程共享区域 1.1.1、堆区 堆区Heap是JVM中最大的一块内存区域，基本上所有的对象实例都是在堆上分配..
spring事务详细讲解-深入浅出
小电玩
09-08 431
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1429
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1358
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 456
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 695
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
"Java类的特性详解及this引用的使用
总之，《第讲-Java类的特性优秀文档.ppt》是一份介绍Java类和对象的详细文档。通过学习该文档，读者可以了解Java类和对象的概念，掌握类的结构和对象生成方法，了解类的特性和打包的使用，掌握常用方法的使用，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值