java类和对象

runing up that hill

已于 2024-07-30 00:07:28 修改

阅读量650

点赞数 20

分类专栏： Java 文章标签： java 开发语言

于 2024-07-27 19:58:30 首次发布

本文链接：https://blog.csdn.net/2201_76124988/article/details/140462022

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

面向对象的认识

什么是面向对象

java是一门纯面向对象的语言，在面向对象的世界里，一切皆为对象，面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事。

面向对象和面向过程

面向过程和面向对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有专门的应用场景。
我们可以通过洗衣服来理解这两种方法，手洗洗衣服需要拿盆，放水，放洗衣粉，换水，手搓、拧干、晒衣服。这可以理解为面向过程语言，注重的是洗衣的过程，不同的衣服洗的方式，时间长度，拧的方式，都是有所区别，所以过程也是需要修改的。
而面向对象可以理解为用洗衣机洗衣服，共有四个对象，洗衣机、人、洗衣粉、水。整个洗衣服的过程：人将衣服放进洗衣机、倒入洗衣粉、启动洗衣机、洗衣机就会完成洗衣过程并且甩干
整个过程主要是：人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关心洗衣机具体是如何洗衣服的，是如何甩干的，以面向对象的方式来处理，就不关注洗衣服的过程，通过对象之间的交互来完成。

类定义和使用

面向对象程序设计关注的是对象，而对象是现实中的一个实体，比如学生，但是计算机并不认识学生这个对象，所以需要程序员来告诉计算机什么是学生，所以我们需要对学生进行简单的描述。

认识类

类是用来对一个实体（对象）进行描述的，主要描述该实体（对象）具有哪些属性和功能？
类的定义格式：

//创建类
class Student{
	//字段（属性）或者成员变量
	//行为或成员方法
}

class为定义类的关键字，Student为类的名字，{}为类的主体
类中包含的内容称为类的成员，属性主要是用来描述类的，称之为类的成员属性或者类成员变量。类主要说明类具有哪些功能，称为类的成员方法。

public class Student {
    public String id;
    public String name;
    public int age;
    public double grade;
    public void eat(){
        System.out.println(name + " 正在吃饭...");
    }
    public void learn(){
        System.out.println(name + " 正在学习...");
    }
}

注意：

类名用大驼峰定义（每个单词首字母大写）
一般一个文件当中只定义一个类
main方法所在的类一般要使用public修饰
public修饰的类必须要和文件名相同
不用轻易去修改public修饰的类名称，如果要修改，建议通过开发工具修改

类的实例化

什么是实例化

定义一个类相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，有了这些类就可以使用这些类来定义实例（或者对象）。
用类类型创建对象的过程，称为类的实例化。在java中使用new关键字，配合类名来实例化对象。

public class Student {
    public String id;
    public String name;
    public int age;
    public double grade;
    public void eat(){
        System.out.println(name + " 正在吃饭...");
    }
    public void learn(){
        System.out.println(name + " 正在学习...");
    }
}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.name = "张三";
        student1.eat();
        student1.learn();
        System.out.println();
        Student student2 = new Student();
        student2.name = "小红";
        student2.eat();
        student2.learn();
        //结果为;
        //张三 正在吃饭...
        //张三 正在学习...
        //
        //小红 正在吃饭...
        //小红 正在学习...
    }
}

注意：

new关键字用于创建一个对象的实例
使用 . 来访问对象中的属性和方法
同一个类可以创建多个实例

类和对象的说明

类是一种自定义的类型，可以用来定义变量，用来对一个实体进行描述，限定了类有哪些成员，相当于一个模型或者说图纸
一个类可以实例化出多个对象，实例化出的对象才能占用实际的物理空间，存储类成员变量，相当于根据图纸建出来的房子，实际占用一定的土地。

this引用

为什么有this的引用

public class Student {
    public String id;
    public String name;
    public int age;
    public double grade;

    public void enroll(String id, String name, int age){
        id = id;
        name = name;
        age = age;
    }
    public void eat(){
        System.out.println(name + " 正在吃饭...");
    }
    public void learn(){
        System.out.println(name + " 正在学习...");
    }
    public void print(){
		System.out.print(id + " " + name + " " + age + " ");
	}
}

在enroll方法的方法体中是谁给谁赋值，成员变量赋值给成员变量，还是参数赋值给参数，还是参数赋值给成员变量，还是成员变量赋值给参数，我们很难搞清楚，我们可以通过验证来看

public static void main(String[] args) {
        Student student1 = new Student();
        student1.enroll("202403","张三",14);
        student1.print();
        System.out.println();
        Student student2 = new Student();
        student2.enroll("202404","李四",16);
        student2.print();
        //结果为;
        //null null 0 
        //null null 0 
    }

我们可以看出此时在方法内，id，name，age 都是局部变量，此时局部变量优先使用，所以没有修改到对象当中的id， name， age
在print方法中，当我们实例化不同对象时，调用print函数又是怎么知道打印哪个对象的成员呢？
答案就是因为存在this这个关键字

什么是this引用

this引用指向当前对象（成员方法运行时调用该成员方法的对象），在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过对所有的操作用户是透明的，即用户不需要来传递，编译器自动完成。
我们可以通过加this引用来使得同名的局部变量变成对象的成员

public class Student {
    public String id;
    public String name;
    public int age;
    public double grade;

    public void enroll(String id, String name, int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + " 正在吃饭...");
    }
    public void learn(){
        System.out.println(name + " 正在学习...");
    }
    public void print(){
        System.out.print(id + " " + name + " " + age + " ");//编译器在编译时会自动加上this
    }
}
public class Test {
	public static void main(String[] args) {
	        Student student1 = new Student();
	        student1.enroll("202403","张三",14);
	        student1.print();
	        System.out.println();
	        Student student2 = new Student();
	        student2.enroll("202404","李四",16);
	        student2.print();
	        //结果为;
	        //202403 张三 14
	        //202404 李四 16
	    }
}

this引用的特性

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

所以 this 的用法有三种：

可以通过 this 访问当前对象的成员变量
可以通过 this 访问当前对象的非静态方法
可以通过 this 访问当前对象的其他构造方法

对象的构造和初始化

通过上面的学习，我们或许有这样的疑问：
是不是我们每次创建类并且创建对象后都需要调用里面用来初始化成员变量的方法（例如上面的enroll）来初始化对象，这样是不是比较麻烦？
为什么创建成员变量的时候可以不用初始化，而局部变量是需要初始化的，否则会编译报错，例如下面的代码：

public static void main(String[] args) {
        int a;
        System.out.println(a);
    }

构造方法

构造方法（也称为构造器）是一个特殊的成员方法，名字必须与类名相同，没有返回值，设置为void都不行，一般情况下，一般情况下用public修饰，在创建对象时，由编译器自动调用，并且在整个生命周期内只调用一次。
一个对象的生成至少有两步很重要，第一步是为对象分配内存，第二步是调用合适的构造方法
构造方法的作用是对对象中的成员进行初始化，并不负责给对象开辟空间
普通方法:

	返回值类型 方法名（形参列表）{
		方法体
}

构造方法：

	方法名（形参列表）{		//方法名需要和类名引用一样
		方法体
}

特性

名字必须与类名相同
没有返回值类型，设置为void也不行
创建对象时由编译器自动调用，并且在生命周期内只调用一次
构造方法可以重载（用户根据自己的需求提供不同参数的构造方法）

public class Student {
    public String id;
    public String name;
    public int age;
    public double grade;

    public Student() {
        
    }

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

    public void enroll(String id, String name, int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + " 正在吃饭...");
    }
    public void learn(){
        System.out.println(name + " 正在学习...");
    }
    public void print(){
        System.out.print(id + " " + name + " " + age + " " + grade);
    }
}

public class Test {

    public static void main(String[] args) {
        Student s1 = new Student("202401","zhangsan",14,90);//此时执行了带参的构造方法
        Student s2 = new Student();//执行了不带参的构造方法
        s1.print();
        System.out.println();
        s2.print();
    }
    //结果为：202401 zhangsan 14 90.0
	//       null null 0 0.0
}

如果用户没有显示定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的，但是一旦用户定义了，就不会自动生成了。
构造方法中，可以通过this调用其他构造方法来简化代码。

public class Student {
    public String id;
    public String name;
    public int age;
    public double grade;

    public Student() {
        this("无","无",-1,-1);
    }

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

    public void enroll(String id, String name, int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + " 正在吃饭...");
    }
    public void learn(){
        System.out.println(name + " 正在学习...");
    }
    public void print(){
        System.out.print(id + " " + name + " " + age + " " + grade);
    }
}

注意：
this（…）必须是构造方法中的第一条语句，否则会报错

public Student() {
        System.out.println();//此时会报错
        this("无","无",-1,-1);
    }

不能形成环

public Student() {
    this("无","无",-1,-1);
}

public Student(String id, String name, int age, double grade) {
    this();
}

默认初始化

局部变量在使用时必须要初始化，否则会编译报错，但是成员变量却不用，这是为什么呢？
如上面的代码中一样，我们在构造方法中并没有初始化，却能打印出 null null 0 0.0 的结果
这new关键字背后的过程有很大关系

Student s2 = new Student();

这虽然只是一条语句，但是在JVM层面需要做很多事

检测对象对应的类是否加载，如果没有加载则加载
为对象分配内存空间
处理并发安全问题
比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
初始化分配的空间
即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，如下表：

数据类型	默认值
byte	0
char	‘\u0000’
short	0
int	0
long	0L
boolean	false
float	0.0f
double	0.0
reference	null

设置对象头信息
调用构造方法，给对象中各个成员赋值

就地初始化

在声明成员变量时，直接给出初始值

封装

封装的概念

面向对象程序的三大特性：封装、继承、多态
封装：套壳屏蔽细节，将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

访问限定符

java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，访问权限用来控制方法或者字段能否直接在类外使用。
java中提供了四种访问限定符：

No	范围	private	没有限定符修饰（默认）	protected	public
1	同一包中的同一类	可以使用	可以使用	可以使用	可以使用
2	同一包中的不同类	不可以	可以使用	可以使用	可以使用
3	不同包中的子类类	不可以	不可以	可以使用	可以使用
4	不同包中的非子类	不可以	不可以	不可以	可以使用

总结：
private修饰的只能在当前包中的当前类中使用
protected主要用于继承
默认、没有修饰符的只能在当前包中使用
public可以任何其他类访问
访问权限除了可以限定类中的成员的可见性，也可以控制类的可见性

认识包

包的概念

在面向对象体系中，提出了软件包的概念，为了更好的管理类，把多个类收集在一起成为一组，称为软件包，类似于目录，本质其实是文件夹。
在java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中类的不想被其他包中的类使用。在同一个工程中允许存在相同名称的类，只要处在不同的包即可。

导入包中的类

java已经提供了很多现成的类供我们使用，例如Arrays类：我们可以使用 java.util.Arrays 导入 java.util 这个包中的 Arrays 类

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

这种写法比较麻烦，也可以使用import导入包

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

如果需要使用 java.util 中的其他类，可以使用 import java.util.* ，但是更建议显式的指定要导入的类名，否则还是容易出现冲突的情况

import java.util.*;    
import java.sql.*;
public class Test {                                                                                 
	public static void main(String[] args) {
	//util和sql都存在一个Date这样的类，此时会出现歧义，编译出错
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

这种情况下需要使用完整的类名

import java.util.*;    
import java.sql.*;
public class Test {                                                                                 
	public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
    }
}

还可以使用import static 导入包中静态的方法和字段

public class Test {
	public static void main(String[] args) {
        double x = 30;
        double y = 40;
        double result = Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
        System.out.println(result);
    }
}

静态导入写起来更简单

import static java.lang.Math.*;
public class Test {
	public static void main(String[] args) {
        double x = 30;
        double y = 40;
        double result = sqrt(pow(x,2) + pow(y,2));
        System.out.println(result);
    }
}

自定义包

基本规则：

在文件的最上方加一个package语句指定该代码在哪个包中。
包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式
包名要和代码路径相匹配
如果一个类没有package语句，则该类放到一个默认包中。

常见的包

java.lang：系统常用基础类(String、Object)，此包从JDK1.1后自动导入。
java.lang.reflect：java反射编程包。
java.net：进行网络编程开发包。
java.sql：进行数据库开发的支持包。
java.util：是java提供的工具程序包。
java.io：I/O编程开发包。

static

public class Student {
    public String id;
    public String name;
    public int age;
    public double grade;
    
    public static int className;

    public Student() {
        this("无","无",-1,-1);
    }

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

在Student类中定义的成员变量，每个对象中都会包含一份（称之为实例变量），因为需要使用这些信息来描述具体的学生，而表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。在java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象共享的。静态的成员只有一份，且存在方法区中。

static修饰成员变量

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

不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。
既可以通过对象访问，也可以通过类名访问，但是一般推荐使用类名访问。
类变量存储在方法区中
生命周期伴随类的一生，随类的加载而创建，随类的卸载而销毁。

public class Student {
    public String id;
    public String name;
    public int age;
    public double grade;

    public static String className = "1班";

    public Student() {
        //System.out.println();
        this("无","无",-1,-1);
    }

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

    public void eat(){
        System.out.println(name + " 正在吃饭...");
    }
    public void learn(){
        System.out.println(name + " 正在学习...");
    }
    public void print(){
        System.out.print(id + " " + name + " " + age + " " + grade);
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Student.className);//通过类名访问
        Student s1 = new Student();
        System.out.println(s1.className);//通过对象访问
    }
}

static修饰成员方法

一般类中的数据成员都设置为private，而成员方法设置为public，所以被private修饰的className如何在类外访问呢？
java中被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象特有的。静态成员一般是通过静态方法来访问的。

public class Student {
    private String id;
    private String name;
    private int age;
    private double grade;

    public static String className = "1班";

    public static String getClassName(){
        return className;
    }
    
    public Student() {
        //System.out.println();
        this("无","无",-1,-1);
    }

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

    public void eat(){
        System.out.println(name + " 正在吃饭...");
    }
    public void learn(){
        System.out.println(name + " 正在学习...");
    }
    public void print(){
        System.out.print(id + " " + name + " " + age + " " + grade);
    }
}

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

静态方法特性：

不属于某个具体的对象，是类方法
可以通过对象调用，也可以通过类名.静态方法名()方式调用，更推荐使用后者
不能在静态方法中访问任何非静态成员变量

public static String getClassName(){
        System.out.println(this);
        return className;
 }
  //编译失败：java: 无法从静态上下文中引用非静态 变量 this

public static String getClassName(){
        age += 1;
        return className;
    }
 //编译失败：java: 无法从静态上下文中引用非静态 变量 age

静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法调用的时候无法传递this引用，静态方法不依赖于对象，可以直接使用类名来访问，但是非静态方法依赖于对象，需要通过对象的引用来访问。

public class Student {
    private String id;
    private String name;
    private int age;
    private double grade;

    private static String className = "1班";

    public static String getClassName(){
        learn();
        return className;
    }
	//编译失败：java: 无法从静态上下文中引用非静态 方法 learn()

    public Student() {
        this("无","无",-1,-1);
    }

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

    public void eat(){
        System.out.println(name + " 正在吃饭...");
    }
    public void learn(){
        System.out.println(name + " 正在学习...");
    }
    public void print(){
        System.out.print(id + " " + name + " " + age + " " + grade);
    }
}

static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种：就地初始化和静态代码初始化。

就地初始化
就地初始化指：在定义时直接给出初始值

public class Student {
    private String id;
    private String name;
    private int age;
    private double grade;

    public static String className = "1班";
}

静态代码块初始化
先了解什么是代码块

代码块

代码块的概念以及分类

使用{}定义的一段代码称为代码块，根据代码块定义的位置以及关键字又可以分为以下四种：

普通代码块
构造代码块
静态代码块
同步代码块（涉及到多线程）

普通代码块

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

public class Test {

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

}
//执行结果：
//10
//100

这种用法比较少见

构造代码块

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

public class Student {
    //实例成员变量
    private String id;
    private String name;
    private int age;
    private double grade;

    private static String className = "1班";

    //实例代码块
    {
        this.id = "无";
        this.name = "无";
        this.age = -1;
        this.grade = -1;
        System.out.println("实例代码块被触发了");
    }

    //构造方法
    public Student(String id, String name, int age, double grade) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.grade = grade;
        System.out.println("构造方法执行了");
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("202401","zhangsan",14,99);
    }
}

//结果为：
//实例代码块被触发了
//构造方法执行了

先执行实例代码块，再执行构造方法
如果一个类中包含多个实例代码块，在编译代码时，编译器会按照定义的先后次序依次执行（合并）
实例代码块只有在创建对象时才会执行。

静态代码块

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

public class Student {
    //实例成员变量
    private String id;
    private String name;
    private int age;
    private double grade;

    private static String className = "1班";

	//静态代码块
    static{
        className = "1班";
        System.out.println("静态代码块被触发了");
    }

    //实例代码块
    {
        this.id = "无";
        this.name = "无";
        this.age = -1;
        this.grade = -1;
        System.out.println("实例代码块被触发了");
    }

    //构造方法
    public Student(String id, String name, int age, double grade) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.grade = grade;
        System.out.println("构造方法执行了");
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("202401","zhangsan",14,99);
        System.out.println("---------------------------");
        Student s2 = new Student("202402","lisi",18,88);
    }
}

//结果为：
//静态代码块被触发了
//实例代码块被触发了
//构造方法执行了
//---------------------------
//实例代码块被触发了
//构造方法执行了

静态成员变量是类的属性，因此是在JVM加载时开辟空间并初始化的，类只加载一次
静态代码块不管生成多少个对象，其只执行一次
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行（合并）
先执行静态代码块，再执行实例代码块，接着执行构造方法，三个执行顺序不会因为代码位置顺序改变而改变，和他们定义的先后顺序没有关系。

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整结构又只为外部事物提供服务，而不需要修改其中的属性，那么这个内部的完整结构最好使用内部类。在java中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

public class OutClass {
    class InnerClass{

    }
}
//OutClass 是外部类
//InnerClass 是内部类

定义在class类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

public class A {

}
class B{

}
//A 和 B 是两个独立的类，彼此之间没有关系

内部类和外部类共用一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

内部类的分类

根据内部类定义的位置不同，一般可以分为以下几种形式：

成员内部类（普通内部类：未被static修饰的成员内部类和静态内部类：被static修饰的成员内部类）
局部内部类、匿名内部类

实例内部类

public class OutClass {
    public int a = 1;
    private int b = 2;
    public static int c = 3;
    class InnerClass{
        public int a = 100;
        private int d = 200;
        public static int e = 300;
        public void test(){
            //在实例内部类中可以直接访问外部类中：任意访问限定修饰的成员
            System.out.println(b);
            System.out.println(c);

            //如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
            System.out.println(a);
            System.out.println(this.a);

            //如果要访问外部类同名成员时候，需要通过：外部类名称.this.同名成员名字
            System.out.println(OutClass.this.a);

            //也可以创建一个指向外部类对象的引用来访问外部类同名成员
            OutClass outClass = new OutClass();
            System.out.println(outClass.a);

            System.out.println(d);
            System.out.println(e);
            System.out.println("test方法被执行了");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //如何实例化一个实例内部类对象
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();

        //也可先创建外部类对象，再创建内部类对象
        OutClass outClass = new OutClass();
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.test();
    }
}
//结果为：
//2
//3
//100
//100
//1
//1
//200
//300
//test方法被执行了

注意：

外部类中的任何成员都可以在实例内部类方法中直接访问
实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员来访问
实例内部类对象必须在先有外部类对象前提下才能创建
实例内部类的非静态方法中包含了一个指向外部类对象的引用
外部类中，不能直接访问实际内部类中的成员，如果要访问必须先要创建内部类的对象。

静态内部类

被static修饰的内部成员类称为静态内部类。

public class OutClass2 {
    public int a = 1;
    private int b = 2;
    public static int c = 3;
    static class InnerClass{
        private int d = 200;
        public static int e = 300;
        public void test(){
            //在静态内部类中只能访问外部类中的静态成员
            System.out.println(a);//编译报错
            System.out.println(b);//编译报错
            System.out.println(c);

            //访问外部类非静态成员可以创建一个指向外部类对象的引用来访问外部类非静态成员
            OutClass outClass = new OutClass();
            System.out.println(outClass.a);

            System.out.println(d);
            System.out.println(e);
            System.out.println("test方法被执行了");
        }
    }
}

public static void main(String[] args) {
        //创建静态内部类对象时，不需要先创建外部类对象
        OutClass2.InnerClass innerClass = new OutClass2.InnerClass();
        innerClass.test();
    }

注意：

在静态内部类中只能访问外部类中的静态成员
创建静态内部类对象时，不需要先创建外部类对象

局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，简单了解语法格式即可

public class OutClass3 {
    public void method(){
        int a = 1;

        //局部内部类：定义在方法体内壁
        //不能被public、static等访问限定符修饰
        class InnerClass{
            public void func(){
                System.out.println(a);
            }
        }

        //只能在方法体内部使用，其他位置都不能使用
        InnerClass innerClass = new InnerClass();
        innerClass.func();
    }
}

public class Test {

    public static void main(String[] args) {
        //OutClass3.InnerClass innerClass = new OutClass3.new InnerClass();//编译失败
        OutClass3 outClass3 = new OutClass3();
        outClass3.method();
    }
}
//结果为：1

注意：

局部内部类只能在所定义的方法体内部使用
不能被public、static等修饰符修饰
编译器也有自己独立的字节码文件，命名格式：外部类名字￥局部内部类名字.class

匿名内部类

匿名内部类涉及到重写，接口等知识，后续了解后继续学习

对象的打印

public class Student {
    private String id;
    private String name;
    private int age;
    private double grade;
    public Student(String id, String name, int age, double grade) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.grade = grade;
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("202401","zhangsan",14,99);
        System.out.println(s1);
    }
}
//结果为：demo1.Student@3b07d329

若想直接打印对象内容，则重写toString方法，什么是重写，为什么需要重写，这需要我们学习完继承和重写就可以完全理解了

public class Student {
    private String id;
    private String name;
    private int age;
    private double grade;
    public Student(String id, String name, int age, double grade) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.grade = grade;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("202401","zhangsan",14,99);
        System.out.println(s1);
    }
}
//结果为：Student{id='202401', name='zhangsan', age=14, grade=99.0}

类和对象我们就先了解到这，后续内容我们后面继续一起学习，共勉！！

runing up that hill

关注

20
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
java类和对象

java是一门纯面向对象的语言，在面向对象的世界里，一切皆为对象，面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事。面向对象程序设计关注的是对象，而对象是现实中的一个实体，比如学生，但是计算机并不认识学生这个对象，所以需要程序员来告诉计算机什么是学生，所以我们需要对学生进行简单的描述。定义一个类相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，有了这些类就可以使用这些类来定义实例（或者对象）
复制链接

扫一扫