【Java】类和对象

已于 2024-03-02 21:45:03 修改
阅读量1.8k 收藏 17
点赞数 60
分类专栏： Java 文章标签： java 开发语言
于 2024-02-24 23:41:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79765510/article/details/136277284
版权

文章目录

一、面向对象的初步认知

1、什么是面向对象

Java是一门纯面向对象的语言(Object Oriented Program，继承OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

2、面向对象与面向过程

1、传统买衣服过程

传统的方式：注重的是洗衣服的过程，少了一个环节可能都不行。
而且不同衣服洗的方式，时间长度，拧干方式都不同，处理起来就比较麻烦。如果将来要洗鞋子，那就是另一种放方式。
按照该种方式来写代码，将来扩展或者维护起来会比较麻烦。

2、现代洗衣服过程

以面向对象方式来进行处理，就不关注洗衣服的过程，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，导入洗衣粉，启动开关即可，通过对象之间的交互来完成的。
注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。

二、类定义和使用

Java是一门纯面向对象的语言(Object Oriented Program，继承OOP)

1、类的定义

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。

2、类的定义格式

在java中定义类时需要用到class关键字，具体语法如下：

// 创建类
class ClassName{
	field; // 字段(属性) 或者 成员变量
	method; // 行为 或者 成员方法
}

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

class WashMachine{
	public String brand; // 品牌
	public String type; // 型号
	public double weight; // 重量
	public double lenght; // 长
	public double weidth; // 宽
	public double height; // 高
	public String color; // 颜色
	public void WashClothes(){ // 洗衣服
		System.out.println("洗衣功能");
	}
	public void dryClothes(){ // 脱水
		System.out.println("脱水功能");
	}
	public void SetTime(){ // 定时
		System.out.println("定时功能");
	}
}

class Dog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

注意事项：
（1）类名注意采用大驼峰定义
（2） 一般一个文件当中只定义一个类
（3）main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的 类中找main方法)
（4）public修饰的类必须要和文件名相同
（5）不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改

三、类的实例化

1、什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：PetDog类和Student类。它们都是类(一种新定义的类型)，有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。
用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。
类只是一个模型/图纸，而通过new关键字实例化对象相当于把这个抽象的东西变成实体。

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog(); //通过new实例化对象
        dog.name = "阿黄"; // 访问类中的成员变量/属性
        dog.color = "黑黄";
        dog.barks(); // 访问类中的成员方法
        dog.wag();
        
        Dog dogs = new Dog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
    }
}

注意事项：
(1) new关键字用于创建一个对象的实例.
(2) 使用 . 来访问对象中的属性和方法.
(3) 同一个类可以创建多个实例.

2、类和对象的说明

  1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.
  2. 类是一种自定义的类型，可以用来定义变量，但是在java中用类定义出来的变量我们称为对象.
  3. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
  4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

四、this引用

1、为什么要有this

下面看一个Date日期类

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

    public void setDay(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) {
        // 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();

        // 对d1，d2，d3的日期设置
        d1.setDay(2020,9,15);
        d2.setDay(2020,9,16);
        d3.setDay(2020,9,17);

        // 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}


以上代码定义了一个日期类，然后main方法中创建了三个对象，并通过Date类中的成员方法对对象进行设置和打印。
（1）将 setDay 方法修改成形参名与成员变量名相同的情况，结果如何？

    public void setDay(int y, int m, int d){
        year = y;
        month = m;
        day = d;
    }

（2）d1、d2、d3都调用了 setDay 和 printDate 方法，它们是如何区分调研哪个对象的？以下 this 可以解答。

2、什么是this引用

java编译器给每个“成员方法“增加了一个隐藏的引用类型参数，该引用参数指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

this引用是编译器自动添加的，用户在实现代码时一般不需要显式给出。一般建议在使用时给出。
注意：this引用的是调用成员方法的对象。

3、this引用的特性

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

五、对象的构造及初始化

1、如何初始化对象

通过前面知识点的学习知道，在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败。

要让上述代码通过编译，只需在正式使用a之前，给a设置一个初始值即可。
如果是对象，需要调用之前写的SetDay方法才可以将具体的日期设置到对象中。

public static void main(String[] args) {
	Date d = new Date();
	d.printDay();
	d.setDate(2021,6,9);
	d.printDate();
}

2、构造方法

2.1 概念

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

public class Date {
	public int year;
	public int month;
	public int day;
	
	// 构造方法：
	// 名字与类名相同，没有返回值类型，设置为void也不行
	// 一般情况下使用public修饰
	// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
	public Date(int year, int month, int day){
		this.year = year;
		this.month = month;
		this.day = day;
		System.out.println("Date(int,int,int)方法被调用了");
	}
	
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day);
    }
    
	public static void main(String[] args) {
		// 此处创建了一个Date类型的对象，并没有显式调用构造方法
		Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
		d.printDate(); // 2021-6-9
	}
}


注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

2.2 特性

  1. 名字必须与类名相同
  2. 没有返回值类型，设置为void也不行
  3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
  4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
public class Date {
	public int year;
	public int month;
	public int day;
	
	// 无参构造方法
	public Date(){
		this.year = 1900;
		this.month = 1;
		this.day = 1;
	}
	
	// 带有三个参数的构造方法
	public Date(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
	
	public void printDate(){
		System.out.println(year + "-" + month + "-" + day);
	}
	
	public static void main(String[] args) {
		Date d = new Date();
		d.printDate();
	}
}

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

  1. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。
public class Date {
	public int year;
	public int month;
	public int day;
	
	public void printDate(){
		System.out.println(year + "-" + month + "-" + day);
	}
	
	public static void main(String[] args) {
		Date d = new Date();
		d.printDate();
	}
}

上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。
注意：一旦用户定义，编译器则不再生成。

public class Date {
	public int year;
	public int month;
	public int day;
	
	public Date(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
	
	public void printDate(){
		System.out.println(year + "-" + month + "-" + day);
	}
	
	public static void main(String[] args) {
		// 如果编译器会生成，则生成的构造方法一定是无参的
		// 则此处创建对象是可以通过编译的
		// 但实际情况是：编译期报错
		Date d = new Date();
		d.printDate();
	}
}
/*
Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
需要: int,int,int
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同
*/
  1. 构造方法中，可以通过this调用其他构造方法来简化代码
public class Date {
	public int year;
	public int month;
	public int day;
	
	// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
	// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
	// 但是this(1900,1,1);必须是构造方法中第一条语句
	public Date(){
		//System.out.println(year); 注释取消掉，编译会失败
		this(1900, 1, 1);
		
		//this.year = 1900;
		//this.month = 1;
		//this.day = 1;
	}
	
	// 带有三个参数的构造方法
	public Date(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
}

注意：
（1）this(…)必须是构造方法中第一条语句
（2）不能形成环

public Date(){
	this(1900,1,1);
}

public Date(int year, int month, int day) {
	this();
}
/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/
  1. 绝大多数情况下使用public来修饰，特殊场景下会被private修饰。

3、默认初始化

Date d = new Date(2021,6,9);

上面的代码在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：

  1. 检测对象对应的类是否加载了，如果没有加载则加载
  2. 为对象分配内存空间
  3. 处理并发安全问题
    比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
  4. 初始化所分配的空间
    即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值
  5. 设置对象头信息
  6. 调用构造方法<>，给对象中各个成员赋值

4、就地初始化

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

public class Date {
	public int year = 1900;
	public int month = 1;
	public int day = 1;
	public Date(){
	}
	public Date(int year, int month, int day) {
	}
	public static void main(String[] args) {
		Date d1 = new Date(2021,6,9);
		Date d2 = new Date();
	}
}

六、封装

1、封装的概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

2、访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：
【说明】
（1）protected主要是用在继承中，
（2）default权限指：什么都不写时的默认权限
（3）访问权限除了可以限定类中成员的可见性，也可以控制类的可见性
注意：一般情况下成员变量设置为private，成员方法设置为public。

3、封装扩展之包

3.1 包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

3.2 导入包中的类

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

public class Test {
	public static void main(String[] args) {
		java.util.Date date = new java.util.Date();
		// 得到一个毫秒级别的时间戳
		System.out.println(date.getTime());
	}
}

但是这种写法比较麻烦一些，可以使用 import 语句导入包。

import java.util.Date;
public class Test {
	public static void main(String[] args) {
		Date date = new Date();
		// 得到一个毫秒级别的时间戳
		System.out.println(date.getTime());
	}
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

import java.util.*;
public class Test {
	public static void main(String[] args) {
		Date date = new Date();
		// 得到一个毫秒级别的时间戳
		System.out.println(date.getTime());
	}
}

但是我们更建议显式的指定要导入的类名，否则还是容易出现冲突的情况。

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());
	}
}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

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

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 导入包中静态的方法和字段。

import static java.lang.Math.*;
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));
		double result = sqrt(pow(x, 2) + pow(y, 2));
		System.out.println(result);
	}
}

注意事项：import 和 C++ 的 #include 差别很大。C++ 必须 #include 来引入其他文件内容，但是 Java 不需要，import 只是为了写代码的时候更方便，import 更类似于 C++ 的 namespace 和 using

3.3 自定义包

【基本规则】
（1）在文件的最上方加上一个 package 语句指定该代码在哪个包中.
（2）包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.frost.demo1 )。
（3）包名要和代码路径相匹配. 例如创建 com.frost.demo1 的包, 那么会存在一个对应的路径 com/frost/demo1 来存储代码。
（4）如果一个类没有 package 语句, 则该类被放到一个默认包中。
【操作步骤】

3.4 包的访问权限控制举例

3.5 常见的包

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

七、static成员

1、static修饰成员变量

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。
【静态成员变量特性】
（1）不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
（2）既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
（3）JDK7及以前，HotSpot(Java虚拟机)中存储在方法区，JDK8及之后，类变量存储在Java堆中
（4）类变量存储在方法区当中
（5）生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

public class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "Bit306";
    // ...
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
        
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
    }
}

同时以调试方式运行上述代码，然后在监视窗口中可以看到，静态成员变量并没有存储到某个具体的对象中。

2、static修饰成员方法

一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何在类外访问呢？

public class Student{
	private String name;
	private String gender;
	private int age;
	private double score;
	
	private static String classRoom = "Bit306";
		// ...
	}
	
	public class TestStudent {
		public static void main(String[] args) {
			System.out.println(Student.classRoom);
	}
}
编译失败：
Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 访问控制

那static属性应该如何访问呢？
Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

public class Student{
    // ...
    private static String classRoom = "Bit306";
    // ...
    public static String getClassRoom(){
        return classRoom;
    }
}
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.classRoom);
    }
}
输出：Bit306

【静态方法特性】
（1）不属于某个具体的对象，是类方法
（2）可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
（3）静态方法没有隐藏的this引用参数，因此不能在静态方法中访问任何非静态成员变量

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

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

（4）静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

public static String getClassRoom(){
	doClass();
	return classRoom;
}
// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

（5）静态方法无法重写，不能用来实现多态

4、static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。
（1）就地初始化
就地初始化指的是：在定义时直接给出初始值

public class Student{
	private String name;
	private String gender;
	private int age;
	private double score;
	private static String classRoom = "frost"; 
	// ...
}

（2）静态代码块初始化

八、代码块

1、代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：
（1）普通代码块
（2）构造块
（3）静态块
（4）同步代码块

2、普通代码块

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

public class Main{
	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

3、构造代码块

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

public class Student{
    //实例成员变量
    private String name;
    private String gender;
    private int age;
    private double score;
    public Student() {
        System.out.println("I am Student init()!");
    }
    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class Main {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.show();
    }
}
// 运行结果
I am instance init()!
I am Person init()!
name: bit age: 12 sex: man

【注意事项 】
实例代码块优先于构造方法执行，因为编译完成后，编译器会将实例代码块中的代码拷贝到每个构造方法第一条语句前。

4、静态代码块

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

public class Student{
	private String name;
	private String gender;
	private int age;
	private double score;
	private static String classRoom;
	
	//实例代码块
	{
		this.name = "bit";
		this.age = 12;
		this.gender = "man";
		System.out.println("I am instance init()!");
	}
	
	// 静态代码块
	static {
		classRoom = "bit306";
		System.out.println("I am static init()!");
	}
	
	public Student(){
		System.out.println("I am Student init()!");
	}
	
	public static void main(String[] args) {
		Student s1 = new Student();
		Student s2 = new Student();
	}
}

【注意事项】
（1）静态代码块不管生成多少个对象，其只会执行一次
（2）静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的Java代码在经过编译器编译之后，如果要运行必须先要经过类加载子系统加载到JVM中才能运行。在加载阶段：在链接阶段第二步准备中会给静态成员变量开辟空间，并设置为默认值，在初始化阶段，会执行静态代码块中的代码。
（3）如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并，最终放在生成的<>方法中，该方法在类加载时调用，并且只调用一次。
（4）实例代码块只有在创建对象时才会执行。

九、内部类

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

public class OutClass {
	class InnerClass{
	
	}
}
// OutClass是外部类
// InnerClass是内部类

【注意事项】
（1）定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

public class A{

}

class B{

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

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

1、内部类的分类

内部类都可以在一个类的那些位置进行定义：

public class OutClass {
    // 成员位置定义：未被static修饰 ---> 普通内部类
    public class InnerClass1{
        
    }

    // 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2{
        
    }

    public void method(){
        // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
        class InnerClass5{
            
        }
    }
}

根据内部类定义的位置不同，一般可以分为以下几种形式：
（1）成员内部类(普通内部类：未static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)
（2）局部内部类(不谈修饰符)、匿名内部类

注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中使用最多的是匿名内部类。

2、成员内部类

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。

2.1 普通内部类

即未被static修饰的成员内部类。

public class OutClass {
    private int a;
    static int b;
    int c;

    public void methodA(){
        a = 10;
        System.out.println(a);
    }

    public static void methodB(){
        System.out.println(b);
    }

    // 成员内部类：未被static修饰
    class InnerClass{
        int c;

        public void methodInner(){
            // 在内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 100;
            b =200;
            methodA();
            methodB();
            
            // 如果外部类和内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 300;
            System.out.println(c);

            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            OutClass.this.c = 400;
            System.out.println(OutClass.this.c);
        }
    }

    public static void main(String[] args) {
        // 外部类：对象创建 以及 成员访问
        OutClass outClass = new OutClass();
        System.out.println(outClass.a);
        System.out.println(OutClass.b);
        System.out.println(outClass.c);
        outClass.methodA();
        outClass.methodB();

        System.out.println("=============内部类的访问=============");
        // 要访问普通内部类中成员，必须要创建普通内部类的对象
        // 而普通内部类定义与外部类成员定义位置相同，因此创建普通内部类对象时必须借助外部类

        // 创建内部类对象
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();

        // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建内部类对象
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.methodInner();
    }
}

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

2.2 静态内部类

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

public class OutClass {
    private int a;
    static int b;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }
    public static void methodB(){
        System.out.println(b);
    }

    // 静态内部类：被static修饰的成员内部类
    static class InnerClass{
        public void methodInner(){
            // 在内部类中只能访问外部类的静态成员
            // a = 100; // 编译失败，因为a不是类成员变量
            b =200;
            // methodA(); // 编译失败，因为methodB()不是类成员方法
            methodB();
        }
    }

    public static void main(String[] args) {
        // 静态内部类对象创建 & 成员访问
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.methodInner();
    }
}

【注意事项】
（1）在内部类中只能访问外部类中的静态成员
（2）创建内部类对象时，不需要先创建外部类对象
（3）成员内部类，经过编译之后会生成独立的字节码文件，命名格式为：外部类名称$内部类名称

3、局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少。

public class OutClass {
    int a = 10;
    public void method(){
        int b = 10;
        
        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }
        
        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }
    
    public static void main(String[] args) {
        // OutClass.InnerClass innerClass = null; 编译失败
    }
}

【注意事项】
（1）局部内部类只能在所定义的方法体内部使用
（2）不能被public、static等修饰符修饰
（3）编译器也有自己独立的字节码文件，命名格式：外部类名字$x内部类名字.class，x是一个整数。
（4）几乎不会使用

十、对象的打印

public class Person {
    String name;
    String gender;
    int age;
    
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}
// 打印结果：day20210829.Person@1b6d3586

如果想要默认打印对象中内如该如何处理呢？答案：重写toString方法即可。

public class Person {
    String name;
    String gender;
    int age;
    
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "[" + name + "," + gender + "," + age + "]";
    }
    
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}
// 输出结果：[Jim,男,18]
frost-cold
关注
  • 60
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java类与对象实验报告心得体会_java类和对象实验报告(共10篇)
weixin_39941847的博客
12-19 4257
java类和对象实验报告(共10篇) 为了适应公司新战略的发展，保障停车场安保新项目的正常、顺利开展，特制定安保从业人员的业务技能及个人素质的培训计划java类和对象实验报告共10篇JAVA程序设计实验报告学生学号班级专业实验六3实验目的.3实验要求.3实验基本内容.3题目一.3题目二.6题目三构造一个矩形类Rectangle，包含求矩形周长和面积的方法.6实验小结.7实验目的理解面向对象的基本概...
java类和对象原理与用法分析
08-25
`this`关键字表示本类对象，用于区分成员变量和局部变量。例如： ```java public class MyClass { private int x; public void myMethod() { int x = 10; this.x = x; // 使用this关键字区分成员变量和局部变量...
java类和对象.ppt
06-04
定义类、属性和方法 创建并使用对象、对象和引用 Java方法的参数传递机制 方法的重载 实现良好的封装 构造方法的作用和构造方法重载
java类和对象
qq_52592775的博客
05-29 5360
自己对于类和对象的一点见解，后面会持续更新
Java类和对象 详解（一）
热门推荐
wei_zhi的博客
10-06 18万+
一、面向对象简述面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实
java类和对象定义语法规范
SPMAX的博客
04-03 3656
学习java的时候，类和对象是两个重要的知识点，他们互相独自存在又互相作用以及密不可分。这篇博客主要总结一下类的语法以及规范。 类是什么？ 首先，java是一门面向对象的语言，而类是对一个对象（实体）进行描述的，主要描述这个对象（实体）有什么属性，有什么功能，然后通过实例化对象来也就是将一个类进行初始化来形成一个具体对象来用。 类的定义格式 简单来说，在java中运用class关键字来修饰，是类。 定义类的时候有几个规范： 1，类名要用大驼峰命名（也就是单词的首字母大写，例如student类
Java基础——类和对象
explorer363的博客
04-26 3万+
本篇博客介绍了Java中类和对象的基本内容，看完本篇博客后，希望大家能对类和对象能有进一步的了解
学习-Java类和对象之对象数组
aiains的博客
06-27 5122
第1关：学习-Java类和对象之对象数组 100 过关任务 参考答案 评论 任务描述 相关知识 编程要求 测试说明 任务描述 本关任务：定义一个 Dog 类，使用对象数组的方式创建 3 个 Dog 对象。 相关知识 所谓的对象数组，就是指包含了一组相关的对象。在使用对象数组的时候，一定要清楚一点：一定要先为数组开辟空间。因为其是引用数据类型，所以数组里面的每一个对象都是 null 值，在使用的时候，数组中的每一个对象必须分别进行实例化操作。 定义对象数组的四个方式： 静态初始化； 类
练习-Java类和对象之this关键字
aiains的博客
06-27 5704
第1关：练习-Java类和对象之this关键字 100 过关任务 参考答案 评论 任务描述 编程要求 测试说明 任务描述 本关任务：定义一个完整的学生类，该类定义了学生的基本信息。 编程要求 仔细阅读右侧编辑区内给出的代码框架及注释，按照提示编写程序代码。 测试说明 平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。 可在右侧“测试结果”区查看具体的测试集详情。 开始你的任务吧，祝你成功！ /** * 任务：定义一个完整的学生类，该类定义了学生的基本信息。
练习-Java类和对象之包的定义
aiains的博客
06-29 8965
第1关：练习-Java类和对象之包的定义 任务描述 编程要求 测试说明 任务描述 本关任务：定义一个电影类和一个电影测试类，在电影测试类中通过对象完成成员变量和成员方法的使用。 编程要求 仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 中完成以下任务： 在 Movie.java 文件中，声明一个名为 com.model 的包； 在该文件中定义一个 Movie 的公开类，该类具有电影名称、电影类别、电影时长、地区等属性（都是字符串类型、私有）； 该类中定
学习-Java类和对象之类的声明之学生类的定义
m0_65420451的博客
08-28 5177
定义一个 Student 学生公开类，该类具有学号 id(int)，年龄 age(int)，grade(int) 等属性； 它们所具有的行为有学习 study()，考试 examination()，讲话 tell()，它们都无返回值和传入的参数。以上就是今天要讲的内容，本文仅仅简单介绍了Java类和对象之类的声明之学生类的定义。...
Java类和对象之间的差
12-22
java类和对象之间的差别是一个普遍的问题，刚开始学习java当它来到与类和对象接触。来总结一下它们之间的差异。 　先说说class和object差异。事实上，词：object是全部class的父类，全部class类都默认继承object。 ...
javaDuiXiang.zip_Java类和对象
09-24
Java类和对象源码,Java实用教程的类和对象源码
JAVA 类和对象的实例
weixin_43805637的博客
01-15 1万+
JAVA 类和对象的实例 什么是类？ 1. 类是具有相同的属性和功能的事物的抽象的集合，在面向对象程序设计中，人们把一类事物的静态属性和动态可以执行的操作组合在一起就得到类这个概念。 2. 类是个抽象的概念，用来模拟一类事物，一旦定义了一个类，这个类就永远存在。 比如：人，人有男人和女人，他们都有身高，体重等相同的属性，他们都具有走路，吃饭，工作等这些相同的，可动态执行的操作，所以可以定义“人类”...
Java爬虫之Jsoup爬Html网页链接
withme977的博客
06-20 273
Java爬虫Jsoup
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 696
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
最新发布
m0_67496588的博客
06-20 946
JSON，Ajax
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 742
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
java类和对象练习
09-03
Java类和对象的练习可以帮助我们理解和掌握面向对象的编程思想和技巧。通过实践，我们可以加深对类和对象的理解，并能够灵活应用于实际项目中。在实际项目中，类和对象是编写高质量、可维护和可扩展代码的基础。所以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值