java中的类和对象

已于 2024-06-04 00:19:30 修改
阅读量97 收藏 8
点赞数 9
分类专栏： JavaSE 文章标签： java 开发语言
于 2023-07-19 22:27:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71627203/article/details/131818210
版权

文章目录

前言

在计算机编程中，不管是面向对象亦或是面向过程都是解决问题的一种思路。而java作为一种面向对象的语言，自然有其独到之处，接下来我们将详细讲解关于java中的类和对象相关知识点。

一、类的定义

1.1 简单认识类

类是用来对一个对象进行描述的，主要描述该实体具有哪些属性，哪些功能。

1.2 类的定义格式

在java中，定义类时需要使用class关键字。 具体语法如下：
类名注意采用大驼峰定义。
class ClassName{ field; // 字段(属性) 或者 成员变量 method; // 行为 或者 成员方法 }
class为定义类的关键字，ClassName为类的名字，{}中为类的主体。
类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

1.3 类的实例化定义

类是用户自定义的一个新的类型，有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。
用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

学习注意点：

  1. 一般一个文件当中只定义一个类。
  2. main方法所在的类一般要使用public修饰。
  3. public修饰的类必须和文件名相同。

1.3.1 对象的定义

1、所谓对象，世间万物皆是对象。若想要将现实世界中的对象抽象成具有特定成员变量及成员方法时就需要引进类。所以成员变量是定义在类里面方法外面的，类名采用大驼峰方式取名。
2、Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

1.3.2 类的定义代码示例（一）

//定义一个洗衣机类型
class WashMachine{
//成员属性/字段：是定义在类里面方法外面的
	public String brand;
	public String type;
	public double weight;
	public double length;
	public double width;
	public double height;
	public String color;

	public void washClothes(){
		System.out.println("洗衣服");
	}
	public void dryhClothes(){
		System.out.println("脱水功能");
	}
	public void setTime(){
		System.out.println("定时功能");
	}
}

1.3.2 类的定义代码示例（二）

//定义一个狗的类型
class petDog{
	public String name;
	public String sex;
	public String color;
	public int age;

	public void eat(){
		Systemout.println("进食");
	}
	
	public void barks(){
		System.out.println("吠叫");
	}
}

1.3.2 类的定义代码示例（三）

//定义一个学生类
class Student{
	public String name;
	public String gender;
	public int age;
	public double score;

	public void DoClass(){
		System.out.println("按时上课，不要迟到，如果迟到，记得请假。";)
	}
	public void DoHomework(){
		System.out.println("课后作业，及时完成，涉及学分，不可懈怠。";)
	}
	public void Exam(){
		System.out.println("考试目的，了解学情，人人关注，注意烦死。";)
	}
}

1.3.3 类的实例化代码示例（一）

//实例化一个类

class Dog{
    public String name;
    public int age;
    public String color;

    public void eat(){
        System.out.println(name + "进食");
    }

    public void barks(){
        System.out.println(name + "吠叫");
    }
}

public class Test{
    public static void main(String[] args){
        Dog petDog = new Dog();
        petDog.name = "初一";
        petDog.age = 10;
        petDog.color = "黄色";
        System.out.println(petDog.name);
        System.out.println(petDog.age);
        System.out.println(petDog.color);
        petDog.eat();
        petDog.barks();

        System.out.println("=====================");

        Dog petDog2 = new Dog();
        //new关键字用于创建一个对象的实例.
        //使用 . 来访问对象中的属性和方法.
        //同一个类可以创建多个实例.
        petDog2.name = "初二";
        petDog2.age = 12;
        petDog2.color = "黑色";
        System.out.println(petDog2.name);
        System.out.println(petDog2.age);
        System.out.println(petDog2.color);
        petDog2.eat();
        petDog2.barks();
    }
}

结果如下：在这里插入图片描述

1.3.3 类的实例化代码示例（二）


//实例化一个日期类并输出值
class Date{
    public int year;
    public int month;
    public int day;

    public void setDate(int y , int m ,int d){
        year = y;
        month = m;
        day = d;
    }
    public void printDate(){
        System.out.println("年:" + year + " "+ "月:" + month + " " + "日:" + day);
    }

    public static void main(String[] args) {
          Date date = new Date();
          date.setDate(2022 , 5 , 20 );
          date.printDate();
       }
  }

结果如下：在这里插入图片描述

1.3.3 类的实例化代码示例（三）

class Student{
    //成员变量定义在方法的外面，类的内部。
    public String name;
    public int age;
    public String gender;

    public void eat(){
        System.out.println(this.name + "正在吃饭");
        //这里的this是当前对象的引用，谁调用eat谁就是this。
    }
}


public class Test{
    public static void main(String[] args) {
        Student student = new Student();
        student.name = "张三";
        student.age = 10;
        student.gender = "男";
        System.out.println(student.name);
        System.out.println(student.age);
        System.out.println(student.gender);
        student.eat();

        System.out.println("=====================");
        
        Student student2 = new Student();
        student2.name = "李素";
        student2.age = 11;
        student2.gender = "女";
        System.out.println(student2.name);
        System.out.println(student2.age);
        System.out.println(student2.gender);
        student2.eat();
    }
}

结果如下：在这里插入图片描述

1.3.3 类的实例化代码示例（四）

class Student{
    public String name;
    public int age;
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.name);//null
        System.out.println(student.age);//0
     //当成员变量没有被赋值时编译器不会报错，只会以自己数据类型的零值进行输出。
     //引用类型一般为null，基本数据类型为0，char类型为“\u0000”，boolean类型为false。
    }
}

结果如下：在这里插入图片描述

1.4 类和对象学习小贴士

  1. 类只是一个类似模型的存在，用来对一个实体进行描述，限定了类有哪些成员变量及成员方法。
  2. 类是一种自定义的类型，可以用来定义属性和行为。
  3. 一个类可以实例化出多个对象，实例化出的对象才真正占用实际的物理空间，存储类成员变量。

1.5 this的使用

1.5.1 什么是this引用？

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

1.5.2 this的使用代码示例（错误示范）

//当局部变量名与对象名冲突时，会产生局部变量优先的问题

class Data{
    public int year;
    public int month;
    public int day;

    public void setDay(int year,int month,int day){
        year = year;//栈区上的局部变量自己给自己赋值，并不影响到引用所指向的对象的成员变量名。
        month = month;//在开辟内存分配的时候，默认值都是0.
        day = day;
    }
    
    public void printDay(){
        System.out.println("年："+ this.year + " " + "月：" + this.month + " " + "日：" 
        											+ this.day + " ");
    }
}

public class Test {
    public static void main(String[] args) {
        Data date = new Data();
        date.setDay(2023 , 7 ,20);
        date.printDay();
        Data date2 = new Data();
        date.setDay(2021 , 1 ,21);
        date.printDay();
    }
}

结果如下：在这里插入图片描述

1.5.2 this的使用代码示例（正确示范）

class Data{
    public int year;
    public int month;
    public int day;

    public void setDay(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    
    public void printDay(){
        System.out.println("年："+ this.year + " " + "月：" + this.month + " " + "日：" 
        											+ this.day + " ");
    }
}

public class Test {
    public static void main(String[] args) {
        Data date = new Data();
        date.setDay(2023 , 7 ,20);
        date.printDay();
        Data date2 = new Data();
        date.setDay(2021 , 1 ,21);
        date.printDay();
    }
}

结果如下：在这里插入图片描述

1.5.2 this的使用代码示例（正确示范）

class Data{
    public int year;
    public int month;
    public int day;

    public void setDay(int y,int m,int d){
        this.year = y;
        this.month = m;
        this.day = d;
    }
    
    public void printDay(){
        System.out.println("年："+ this.year + " " + "月：" + this.month + " " + "日：" 
        											+ this.day + " ");
    }
}

public class Test {
    public static void main(String[] args) {
        Data date = new Data();
        date.setDay(2023 , 7 ,20);
        date.printDay();
        Data date2 = new Data();
        date.setDay(2021 , 1 ,21);
        date.printDay();
    }
}

结果如下：在这里插入图片描述

1.5.3 this学习小贴士

  1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
  2. this只能在"成员方法"中使用
  3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象
  4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法 对象的引用传递给该成员方法，this负责来接收

二、构造方法

2.1 构造方法的定义

构造方法即构造器，是一个特殊的成员方法。方法名必须与类名保持一致并且不存在返回值，在创建对象时由编译器自动调用，并且在整个对象的生命周期内只调用一次。

当调用完构造方法之后对象才产生。当一个类当中没有出现任何一个构造方法时，java会自动帮你提供一个不带参数的构造方法。但当类中出现过构造方法(无论是否存在参数列表都可)，java便不会再自动帮你提供构造方法

构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。
完成一个对象的构造：需要先分配空间，然后在调用合适的构造方法。

2.2 构造方法的使用

2.2.0 就地初始化

class Student{
    public String name = "初一";
    public int age = 12;

    public  Student(){
    }
    public  Student(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("带2个参数的构造方法");
    }
    public void eat(){
        System.out.println(name + "正在吃饭");//
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

结果如下在这里插入图片描述

2.2.1 构造方法的错误示范

class Student{
    public String name;
    public int age;
    
    public  Student(String name, int age){
        this.name = name;//zhangsan
        this.age = age;//22
        System.out.println("带2个参数的构造方法");
    }
    public void eat(){
        System.out.println(name + "正在吃饭");//zhangsan正在吃饭
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();//实例化的对象会自动调用不带参数的构造方法
        Student student2 = new Student("zhangsan",22);//实例化的对象会自动调用带参数的构造方法
    }
}

结果如下在这里插入图片描述

2.2.2 构造方法的正确示范

class Student{
    public String name;
    public int age;

    public Student(){
        System.out.println("不带参数的构造方法");
    }
    public  Student(String name, int age){
        this.name = name;//zhangsan
        this.age = age;//22
        System.out.println("带2个参数的构造方法");
    }
    public void eat(){
        System.out.println(name + "正在吃饭");//zhangsan正在吃饭
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();//实例化的对象会自动调用不带参数的构造方法
        Student student2 = new Student("zhangsan",22);//实例化的对象会自动调用带参数的构造方法
    }
}

结果如下在这里插入图片描述

2.2.3 通过构造方法实例化对象

class Student{
    public String name;
    public int age;

    public Student(){
        this("张三" , 10);
        System.out.println("不带参数的构造方法");
    }

    public Student(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("带2个参数的构造方法");
    }
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

结果如下在这里插入图片描述

2.2.4 通过this在构造方法中实例化（一）

class Student{
    public String name;
    public int age;

    public Student(){
        this("张三" , 20);
       //this()调用在一个构造方法中调用当前类的其他构造函数，但只能在构造方法内部使用,且必须是第一行
        System.out.println("不带参数的构造方法");
    }

    public Student(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("带2个参数的构造方法");
        System.out.println(this.name);
        System.out.println(this.age);
    }

    public void eat(){
        System.out.println(name + "正在吃饭");
    }
}

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

结果如下在这里插入图片描述

2.2.4 通过this在构造方法中实例化（二）

class Student{
    private String name;
    private int age;

    public void  eat(){
        System.out.println(this.name + "正在吃饭");
    }

    public String getName(){
        return this.name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return this.age;
    }

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

结果如下在这里插入图片描述

2.2.5 通过构造方法实例化（四）

class Person{
    private String name;
    private int age;
    private String sex;

    public Person() {
        this("张三",10,"女");
    }

    public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println(this.sex);
        System.out.println(this.age);
        System.out.println(this.name);
    }

    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;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

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

结果如下在这里插入图片描述

2.2.5 通过构造方法实例化（五）

class Person{
    private String name;
    private int age;
    private String sex;

    public Person() {
    }

    public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println(this.sex);
        System.out.println(this.age);
        System.out.println(this.name);
    }

    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;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        System.out.println(person.getName());
        person.setAge(19);
        System.out.println(person.getAge());
        person.setSex("女");
        System.out.println(person.getSex());
    }
}

结果如下在这里插入图片描述

三、封装

3.1 封装的定义

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。

所谓封装：就是将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

3.2 访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，而访问权限用来控制方法或者字段能否直接在类外使用。
Java中提供了四种访问限定符：public、default、protected、private在这里插入图片描述

3.3 封装的代码示例

class Student{
    private String name;
    private int age;

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

    public String getName(){
        return this.name;
    }
}

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

结果如下在这里插入图片描述

3.4 自动封装的代码示例

class Student{
    private String name;
    private int age;

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student() {
    }
    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(10);
        System.out.println(student.getName());
        Student student2 = new Student("李四",14);
    }
}

结果如下在这里插入图片描述

四、包

4.1 包的定义

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。
在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在
不同的包中即可。

4.2 包的使用代码示例（一）

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] array = { 1, 2 ,3 ,4 };
        System.out.println(Arrays.toString(array));
        java.util.Date date = new java.util.Date();
    }
}

结果如下在这里插入图片描述

4.2 包的使用代码示例（二）

import java.util.Arrays;
import java.util.Date;
public class Test {
    public static void main(String[] args) {
        int[] array = { 1, 2 ,3 ,4 };
        System.out.println(Arrays.toString(array));
        Date date = new Date();
    }
}

在这里插入图片描述

4.2 包的使用代码示例（三）

import java.util.*;
public class Test {
    public static void main(String[] args) {
        int[] array = { 1, 2 ,3 ,4 };
        System.out.println(Arrays.toString(array));
        Date date = new Date();
    }
}

结果如下在这里插入图片描述

4.2 包的使用代码示例（四）

class Student{
    private String name;
    private int age;
    public  static String classRoom;

    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student("张三",10);
        Student student2 = new Student("李四",10);
        System.out.println(student.getAge());
        System.out.println(student2.getAge());

        System.out.println(student.getName());
        System.out.println(student2.getName());

        Student.classRoom = "109";
        System.out.println(Student.classRoom);
    }
}

结果如下在这里插入图片描述

4.2 包的使用代码示例（五）

public class Test {
    public static void main(String[] args) {
        double ret = Math.sqrt(Math.pow(3,2) + Math.pow(7,5));
        //double ret = sqrt(pow(3,2) + pow(7,5));
        System.out.println(ret);
    }
}

结果如下在这里插入图片描述

4.3 自定义包基本规则

  1. 在文件的最上方加上一个 package 语句指定该代码在哪个包中。
  2. 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式。
  3. 包名要和代码路径相匹配。

五、static 成员变量的使用

5.1 static修饰成员变量和方法的注意事项

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

  1. 静态成员变量不属于某个具体的对象，是类的属性，为所有对象共享。不存储在某个对象的空间中，而是单独存储在方法区中。
  2. 静态成员变量和静态成员方法既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问。
  3. 静态成员变量的生命周期伴随着类的一生，它随着类的加载创建，随着类的卸载而销毁)。

5.2 static修饰成员变量和方法代码示例

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

    public static void show(){
        System.out.println("测试静态方法调用");
    }

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

public class Test {
    public static void main(String[] args) {
        Student.classRoom = "109";//静态成员变量直接使用类名.即可访问
        System.out.println(Student.classRoom);
        Student.show();

        Student student = new Student();
        student.setAge(17);
        System.out.println(student.getAge());
        student.setName("王五");
        System.out.println(student.getName());
    }
}

结果如下在这里插入图片描述

5.3 静态方法如何调用非静态方法

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

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public void show(){
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
    public static void func(){
 //静态方法中不可以直接调用非静态方法和普通成员变量，需要先实例化生成引用。这也就意味着不能使用this
        Student student = new Student();
        student.show();
    }
}

public class Test {
    public static void main(String[] args) {
        Student.classRoom = "109";//静态成员变量直接使用类名.即可访问
        System.out.println(Student.classRoom);

        Student student = new Student();
        student.setAge(17);
        System.out.println(student.getAge());
        student.setName("王五");
        System.out.println(student.getName());
        student.show();
    }
}

结果如下在这里插入图片描述

六、代码块

6.1 普通代码块

使用 { } 定义的一段代码称为代码块。普通代码块是定义在方法中的代码块。

public class Test {
    public static void main(String[] args) {
        {
            int x = 10;
            System.out.println(x);
        }
        System.out.println(x);//error
    }
}

结果如下在这里插入图片描述

6.2 构造代码块

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

class Student{
    public String name;
    public int age;
    public static String classRoom = "109";

    {
        this.name = "小丽";
        this.age = 19;
        System.out.println("实例代码块");
    }
    public Student(){
        System.out.println("不带参数的构造方法");
    }
    
    public void show(){
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
}


public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.show();
    }
}

结果如下在这里插入图片描述

6.3 静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

class Student{
    public String name;
    public int age;
    public static String classRoom ;

    {
        this.name = "小丽";
        this.age = 19;
        System.out.println("实例代码块");//实例化对象时才会执行
    }
    public Student(){
        System.out.println("不带参数的构造方法");
    }

    static {
        classRoom = "中文一班";
        System.out.println("静态代码块");
    }
    public void show(){
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
}


public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.show();
    }
}

结果如下 在这里插入图片描述

6.4 学习小贴士

class Student{
    public String name;
    public int age;
    public static String classRoom ;

    {
        this.name = "小丽";
        this.age = 19;
        System.out.println("实例代码块");
    }
    public Student(){
        System.out.println("不带参数的构造方法");
    }

    static {
        classRoom = "中文一班";
        System.out.println("静态代码块");
    }
    public void show(){
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
}

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

结果如下在这里插入图片描述

1.静态成员变量是类的属性，因此是在JVM加载类时就开辟空间并初始化的，所以静态代码块不管生成多少个对象，都只会执行一次。并且优于实例代码块及构造代码块先执行。
2.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并执行，实例代码块只有在创建对象时才会执行。

六、对象的打印

6.1 对象的打印代码示例

6.1.1 成员变量未被初始化

//未被初始化的类的成员变量
public class Test {
    String s;//类的成员变量

    public static void main(String[] args) {
        Test test = new Test();//实例化类
        System.out.println(test.s);//NULL
    }
}

结果如下在这里插入图片描述

6.1.2 局部变量未被初始化

//未被初始化的局部变量
public class Test {
    public static void main(String[] args) {
        String s;
        System.out.println(s);//编译不通过，局部变量必须初始化
    }
}

结果如下在这里插入图片描述

6.1.3 静态方法的调用

//静态方法的调用
class Student{
    public static void hello(){
        System.out.println("hello");
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = null;//null表示此时不指向任何对象，因为静态方法不依赖于对象所以可以编译通过
        Student.hello();//hello
    }
}

结果如下在这里插入图片描述

6.1.4 非静态方法的调用

//非静态方法的调用
 class Student{
    public  void hello(){
        System.out.println("hello");
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = null;//空指针异常
        student.hello();//hello
    }
}

结果如下在这里插入图片描述

6.1.5 静态对象的调用

class Student{
    public String name;
    public 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;
    }

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {

    public static void main(String[] args) {
        Student student = new Student("王五",12);
        System.out.println(student);
    }
}

结果如下在这里插入图片描述

Mo_吉托的莫。
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
Java中的类和对象
GuessHat的博客
06-18 444
Java中的类和对象 Java中的类 其实对应 面向对象 中的 “对象” class 定义的东西 Java中的对象 对应面向对象中 那个具体事物。 是 new 类 出来的东西。 1.Java中的属性和方法 面向对象中主要关心对象具备什么样的功能。细分两部分： 特征：用于描述对象（颜色、品牌…） 变量来描述 行为： 能做什么（跑，放音乐，拉货…) 方法来描述 2.类的定义 class 类名{ 数据类型 变量名； //描述特征 修饰符 返回值类型 方法名(参数类型 参数名,.....){ }
JAVA中的类
最新发布
z972065491的博客
09-16 1万+
java基础
Java中的类
qq_45866503的博客
10-25 147
Java中的类 对Java类的描述 类是对象的模子，具有相同属和方法的一组对象的集合，类是不存在的，是用来描述对象信息。在计算机的世界里面，计算机关注的是数据信息，我们描述数据信息的时候一定要描述数据类型，对象就是具体的数据信息，类是信息的数据类型。 ​ 简而言之，类是一个模板，它描述一类对象的属性和行为；类是表示一个客观世界某类群体的一些基本特征抽象。 类的结构 成员变量：对象属性的描述； 【对某种事务特征的描述（这个类有什么）】 方法：对象的行为；（可以做的事情） 【对某种事务行为的规定（这个类
Java常用类详细讲解
weixin_45536242的博客
07-08 734
Java提供了强大的基础类库，可以简化开发，提高开发效率。这些类根据功能不同被划分到不同的包中，用户程序需要将其使用import关键字导入方可使用。本章将针对java.lang包、java.time包以及java.util包中的一些常用类进行讲解，包含字符串类、日期类、系统类、包装类以及数学相关类。5 6 7 8 9 9.1 String类在前面的内容中经常见到String类，使用它来定义一...Java提供了强大的基础类库，可以简化开发，提高开发效率。这些类根据功能不同被划分到不同的包中，用户程序需要将其
java方法
weixin_48767006的博客
07-14 388
目录1、方法的定义2、带返回类型的方法定义3、返回类型：4、方法的重载5、JVM内存模型变化6、方法的递归return 的作用：结束当前的方法，可以单独用，还可以带返回类型用八大基本数据类型引用数据类型void(没有返回)注意：方法的可变参数底层实际上就是数组 定义：同一个类里面，方法允许存在一个以上的同名方法，要求参数列表不同参数列表不同：1.参数类型不同2.参数顺序不同3.参数个数不同和返回值类型无关 栈：是线程私有的，生命周期与线程相同，线程之间不共享，里面拥有多个栈帧局部变量方法内定义的局部变量
java中的类介绍
wyqwilliam的博客
05-27 1591
代码的结果 (1)外层框架 public class HelloWorld { //HelloWorld叫作类的名称(类名) } 公共的类名必须与文件名同名 public class HelloWorld{ } class Hello{ } class World{ } 一个文件中可以有N多个class,只能有一个为 pu...
java类和对象.ppt
06-04
定义类、属性和方法 创建并使用对象、对象和引用 Java方法的参数传递机制 方法的重载 实现良好的封装 构造方法的作用和构造方法重载
Java-类和对象
12-22
功能：初始化当前类对象中保存的成员变量数据。 一个类当中没有显式的声明构造方法的时候，Java编译器会默认的为其提供一个无参的构造方法，供其使用。 如果在一个类当中显式的声明了构造方法，不管式无参还是有参，...
深入理解Java 对象和类
09-02
【深入理解Java对象和类】 Java是一种面向对象的编程语言，其核心概念包括对象、类、多态、继承、封装、抽象以及实例、方法和消息解析。本文将着重探讨对象和类这两个基本概念。 **对象**是类的一个实例，具备状态...
浅析Java编程中类和对象的定义
09-02
在Java编程中，类和对象是面向对象编程的基础概念，它们是构建程序的基本构造块。本文将深入浅出地解析这两个核心概念。 1. **什么是类？** 类是Java中用于描述一类具有相似属性和行为的事物的蓝图或者模板。它...
Java中类的概念
热门推荐
坍塌的博客
04-25 3万+
Java中类的概念 类：类是一个模板，它描述一类对象的行为和状态。 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状 态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等 Java中的类 定义一个类的基本格式 [修饰符] class 类名{ 0到多个构造器 0到多个成员变量 0到多个方法 0到多给初始化块 } 修饰符可以写public final abstract或者不写，jav...
java中的类
一个小白
08-06 8905
4.1.类是什么？   1.类–类型–数据类型—复合数据类型—自定义复合数据类型   为什么有复合数据类型？   基本数据类型就8种，在开发中远远不够，所以我们就需要一个可以根据自己的需求随时能制作出一个自己需要的数据类型。   2.类–具有共同性质的一组事物的群体。 人类。   在java中用来描述具有共同性质的一组事物的自定义的复合数据类型—类。   复合数据类型的本质—【根据自己的
java 中常用类的介绍以及说明
qq_35449428的博客
03-28 1374
1、String类方法编程练习题：重点掌握思想  1，需求：将字符串中进行反转。abcde --> edcba思路：1、因为反转，想到之前做个数组的反转的例子，1、先将字符串转变为数组。2、有了数组后直接进行头尾角标元素的位置置换即可3、将数组转成字符串。步骤：1、将字符串转成数组：toCharArray();2、对数组进行位置置换swap()3、将数组转成字符串，用字符串构造函数就可以了。...
Java类的基本描述
aa80303857的博客
10-13 1313
Java是面向对象的编程语言,其中对象是类的实例,类是对象的模板. 类可以封装属性,方法. Box b1 = new Box(); Box b2 = b1; 这个时候b1与b2指向的是同一个对象. b1 = null; 将b1设置为null之后并不会影响b2,b2仍指向原始对象,b1的这种操作叫做与原始对象"脱钩" ...
Java中常用类的介绍
随笔记
07-23 6865
打个广告，帮朋友卖点东西，东西超便宜的哟【衣服鞋子等】，厂家直接出货，绝对低于市场价！！！一般都比市场价便宜3—7折【都是牌子货】，如果您感兴趣，可以扫描屏幕下方的二维码，感谢关注！！！ 微信 String类 构造方法： String() 初始化一个新创建的 String 对象，它表示一个空字符序列。 String(String orig) 初始化一个新创建的 Str...
java中关于类的描述_java笔记2：Java语言中的类和对象的描述
weixin_35531655的博客
02-25 1111
在Java 语言中，除8 个基本数据类型值之外， 一切都是对象，而对象就是面向对象程序设计的中心。对象是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。对象具有状态， 一个对象用数据值来描述它的状态。Java 通过为对象定义成员变量来描述对象的状态。对象还有操作，这些操作可以改变对象的状态，对象的操作也被称为对象的行为， ...
浅谈JAVA中类的几种关系
android_seven的博客
09-13 5583
   作为一个程序员，我们难免要绘制一些UML类图，所以我们先要搞清楚类与类之间的关系，下面就简单的介绍下我们日常的类关系。    一般来说，类与类之间有以下几种关系，依赖、关联、聚合、组合、继承（泛化）、实现。并且这几种关系耦合性是逐渐增强的，下面我们就简单的介绍下这几种关系种关系：   1.依赖（Dependency）：对象之间最弱的一种关联方式，是临时性的关联。代码中一般指由局部变量、...
java中对于类的了解
issa的博客
12-24 467
1.java中的万事万物都由类组成，而类可以说是对象的载体（相当于类）。 2.类由属性与行为组成，属性————成员变量；行为————成员方法（相当于函数）。 举个例子，人（对象）-----高，矮，瘦，胖（成员变量）；------走路，吃饭，上班（成员方法） calss person{ String name="xxxx";//---| int income=1000;// |----成员变量 boolean married;//-----| public void
Java类与对象：属性和方法详解
"Java编程中的类与对象，包括属性和方法的定义以及对象的使用" 在Java编程中，类和对象是核心概念，用于构建复杂软件系统的基础结构。类是对象的蓝图，它定义了一组相关属性和方法的集合。属性（Attributes）是对象...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Mo_吉托的莫。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值