关于java中类和对象的学习总结

类就是一个类型，想是基本数据类型一样的东西（int，byte，short，long，double，flout，Boolean，char），只是说是自己创建的用于整合成员变量和成员方法之类的一个类型，类是用来描述对象的

类的创建格式如下：
class （类名）{
成员变量
成员方法
{
代码块
}
......
}

此时就可以在其中编写自己的类了，我在学习时好奇类和方法有哪些区别是注意到，方法是写在由public所修施的类中（即要和文件名相同），如我创建了个Test.java的文件

点击查看代码

public class Test {

   public static String myString(int[]arrar){
       String arr = "";
       arr += "[";
       int a = 0;
       for(int i = 0 ;i < arrar.length;i++){
           arr += arrar[i];
           if(i < arrar.length - 1){
               arr += ", ";
           }
       }
       arr += "]";
       return arr;
    }
public static void main(String[] args){
    int[] arrar = {1,2,3,4,5};
}

这是个以数组方式打印数组的函数myString，我们可以注意到他是写在Test中的而类是写在Test类之外的，如

点击查看代码

class Date{
    public int name = 0;
    public void printName{
    System.out.println("姓名：" + name);
    
}
public class Test {
public static void main(String[] args){
    Date data = new Date();
}
}

注意类名要用大驼峰的方法命名，public修饰的类要和文件名相同我在main中用类创建了一个对象，格式如下

类名对象 = new 类名（参数）

类是用户自定义的一个新类型，用类创建对象的过程叫做实例化，要配合new关键字

同一个类可以创建多个对象

在类中方法成员外的是成员变量,对象名是放在栈区中的，存放的是指向对象的地址
可以使用.引用对象中的元素的，如

点击查看代码

class Date{
    public int name = 0;
    public void printName(){
    System.out.println("姓名：" + name);
}
}
public class Test {
public static void main(String[] args){
    Date data = new Date();
    data.name = 10;
    System.out.println(data.name)
    data.printName();
}
}

输出为 10 姓名：10

此时就可以调用并打印Data里面的name了
注意局部变量如果没有初始化会报错，但是在成员变量中没有这个问题，即使没有初始化也会有默认值
默认值中如果是基本数据类型就是0，应用类型就是null

.不仅可以访问成员变量，还可以访问成员方法,方法就是上图所示
同一个类可以实例化多个对象

那么该如何向对象传参呢

点击查看代码

class Date {
    public int name = 0;
    public  int x;
    public  int y;
    public void printName() {
        System.out.println("姓名：" + name);
    }
    public void printInt(int x,int y){
        x = x;
        y = y;
        System.out.println(x);
        System.out.println(y);
    }
}
public class test {
public static void main(String[] args) {
            int[] arrar = {1, 2, 3, 4, 5};
            Date data = new Date();
            data.printInt(10,20);
        }
    }

这是用方法传参的一个方法,在方法中x，y都是局部变量，此时局部变量优先使用，我这里是形参和成员变量同名的情况如果你写成下面的方法就会这样

点击查看代码

class Date {
    public int name = 0;
    public int x = 0;
    public int y = 0;
    public void printName() {
        System.out.println("姓名：" + name);
    }
    public void printInt(int x,int y){
        x = x;
        y = y;

    }
} 
public class test {
public static void main(String[] args) {

            Date data = new Date();
            data.printInt(10,20);
            System.out.println(data.x);
            System.out.println(data.y);
        }
    }

就会输出 0 0 就是因为在优先使用局部变量的情况下会出现形参自己赋值给自己的情况，那该如何避免呢这是就该this登场了

点击查看代码

class Date {
    public int name = 0;
    public int x = 0;
    public int y = 0;
    public void printName() {
        System.out.println("姓名：" + name);
    }
    public void printInt(int x,int y){
        this.x = x;
        this.y = y;

    }
} 
public class test {
public static void main(String[] args) {

            Date data = new Date();
            data.printInt(10,20);
            System.out.println(data.x);
            System.out.println(data.y);
        }
    }

这时候就会出现想要的值了 this代表引用当前对象，在出现一个类实例化多个对象的时候，哪个对象引用了成员方法就调用该对象内的变量，即this引用的是调用该成员方法的对象。

在成员方法中对成员变量的操作都可以用this引用去访问，建议习惯的去写this

注意this只能在成员方法中使用，静态方法不能使用this

使用this可以访问成员变量
使用this可以访问非静态成员方法
使用this可以访问其他构造方法（下面提到

那就有个问题，问什么成员变量不需要初始化呢？
这就涉及到构造方法了
构造方法是一个特殊的成员方法，其名字必须要和类名相同，在创建变量是会自动运行，在对象的生命周期内只会调用一次，且构造方法不存在返回值

点击查看代码

class Date {
    public int name = 0;
    public int x = 0;
    public int y = 0;
    public void printName() {
        System.out.println("姓名：" + name);
    }
    public void printInt(int x,int y){
        this.x = x;
        this.y = y;
    }
    public Date(){
        System.out.println("这是构造方法");

    }
}


    public class test {



        public static void main(String[] args) {

            Date data = new Date();
            data.printInt(10,20);
            System.out.println(data.x);
            System.out.println(data.y);
        }
    }

运行输出结果如下

这是构造方法
10
20

构造方法会给对象中的成员初始化，在一个方法中构造方法可以不只一个，如果你没有构造方法，那么编译器会自动生成个无参的构造方法
构造方法可以重载

点击查看代码

class Date {
    public int name = 0;
    public int x = 0;
    public int y = 0;
    public void printName() {
        System.out.println("姓名：" + name);
    }
    public void printInt(int x,int y){
        this.x = x;
        this.y = y;
    }
    public Date(){
        System.out.println("这是构造方法");
//这里也要注意不要发生递归
    }
    public Date(int x,int y){
        this();//这里调用的其他的构造方法，并且记得要放在第一位不然会报错
        this.x = 10;
        this.y = 20;

    }
}


    public class test {



        public static void main(String[] args) {

            Date data = new Date();
            data.printInt(10,20);
            System.out.println(data.x);
            System.out.println(data.y);
        }
    }

以上就是发生重载，同时还可以再构造方法中使用类中的其他成员方法

那到底为什么成员变量不需要初始化，而局部变量需要呢？
这就要从new讲起了

jdk内包含java虚拟机（jvm），程序在jvm中要做很多事，比如加载类，分配内存等，在这个过程中会初始化分配的内存，对象空间分配空间时会自动初始化

差不多就是这个样子

之前加载过的类就不会在加载了，这也是jvm的优点

那么类里面的public这些是什么，有什么用呢？

这些叫做访问限定符，这就是封装
public即公开，非同一包非子类能用
protected比public严点，非同一个包子类能用
default在只能同一个包内访问（默认权限，什么都不写就行
private只能在同一个包同一个类访问

那么什么是包呢？可以理解为文件夹，用于整合类的
System.out.println()其实就是在调用包内的类的方法
也可以用import导入包，如
import java.util.*
*代表包内所有的类，但不建议，可能会冲突，比如两个不同的包有相同的类，就会报错
可以用import static 导入静态的方法

那么静态成员变量怎么访问？就是用类名引用访问，当然用对象也行，但与其本质不一样，不建议
静态的不依赖于对象
也就是说，即使你没有实例化也可以用

点击查看代码

class Date {
    static int age ;
    public int name = 0;
    public int x = 0;
    public int y = 0;
    public void printName() {
        System.out.println("姓名：" + name);
    }
    public void printInt(int x,int y){
        this.x = x;
        this.y = y;
    }
    public Date(){
        System.out.println("这是构造方法");
//这里也要注意不要发生递归
    }
    public Date(int x,int y){
        this();//这里调用的其他的构造方法，并且记得要放在第一位不然会报错
        this.x = 10;
        this.y = 20;
        this.printInt(100,200);
    }
}


    public class test {



        public static void main(String[] args) {

            Date data = new Date();
            data = null;
            data.age = 10;
            System.out.println(data.age);
        }
    }

可以输出10 说明静态变量不依赖于对象静态成员变量和静态成员方法存放于方法区，在jvm中，随类的创建而创建，销毁而销毁

静态成员方法中不能调用非静态方法，但非静态方法可以调用静态方法
因为静态方法不依赖与对象，但非静态方法依赖于对象

关于类中的访问顺序如下
1.静态代码块
2.非静态代码块
3.构造方法
如果有相同属性的就按照顺序访问

那么关于类和对象的学习就到这里，作为一个Java小白了解不多，如有错误望指正，感谢

posted @ 2025-12-19 15:50 alexacaily36 阅读(8) 评论(0) 收藏举报

刷新页面返回顶部

关于java中类和对象的学习总结

公告