JavaSE基础语法之类和对象
目录
前言
一、面向对象的初步认识
1.什么是面向对象
2.面向对象和面向过程
二、类定义和使用
1.类的简单介绍
2.类的定义格式
三、类的实例化
1.什么是实例化
四、this引用
1.什么是this引用
2.this引用的特性
五、对象的构造及初始化
1.如何初始化对象
2.构造方法
（1）概念
（2）特性
3.默认初始化
4.就地初始化
六、封装
1.封装的概念
2.访问限定符
3.包
（1）包的概念
（2）导入包中的类
（3）自定义包
七、static成员
1.static修饰成员变量
2.static修饰成员方法
3.static成员变量初始化
八、代码块
1.代码块概念以及分类
2.普通代码块
3.构造代码块
4.静态代码块
九、内部类
1.内部类
（1）实例内部类
（2）静态内部类
2.局部内部类
3.匿名内部类
十、对象的打印
总结
前言
Java 作为一门纯面向对象的编程语言，那么我们学习面向对象的思想就是极为重要的，而学习面向对象思想的第一个内容，就是类和对象
一、面向对象的初步认识
1.什么是面向对象
Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情
2.面向对象和面向过程
面向过程注重的是过程，事必躬亲，少一环都不行，如果按照这种方式写代码，将来 扩展或维护起来会比较麻烦
面向对象不注重内部代码如何实现，是通过对象之间的交互来完成的
二、类定义和使用
1.类的简单介绍
类是用来对一个实体（对象）来进行描述的
2.类的定义格式
语法：
//创建类
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("定时功能");
}
}注意事项：
- 类名注意采用大驼峰定义
- 成员前写法统一为public，后面详细介绍
- 此处写的方法不带static关键字，后面详细介绍
- 一般一个文件当中只定义一个类
- main方法所在的类一般用public修饰（注意：Eclipse默认会在public修饰的类中找main方法）
- public修饰的类必须要和文件名相同
- 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改
三、类的实例化
1.什么是实例化
定义了一个类，就相当于在计算机中定义了一种新的类型。然后就可以使用这些类来定义实例（或者称为对象）
用类类型创建对象的过程，称为类的实例化，在Java中采用new关键字，配合类名来实例化对象
注意事项：
- new关键字用于创建一个对象的实例
- 使用 . 来访问对象中的属性和方法
- 同一个类可以创建多个实例
- 类只是模型一样的东西，实例化出的对象 占用实际的物理空间 ，只存储类成员变量
四、this引用
1.什么是this引用
this 引用指向当前对象（成员方法运行时调用该成员方法的对象），在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要传递，编译器自动完成
代码示例：
public class Student {
public String name;
public int age;
public void setStudent(String name,int age){
//当形参变量名与成员变量名一致时，如果不加this，则遵循局部变量优先的原则
//形参变量值赋值给形参变量，对象中的成员变量值不变
this.name = name;
this.age = age;
}
public void printStudent(){
System.out.println("name:" + this.name);
System.out.println("age:" + this.age);
}
public void fun(){
//可以使用this在一个方法中调用另一个方法
this.printStudent();
}
}注意：this引用的是调用成员方法的对象，建议以后养成写this的习惯
2.this引用的特性
- this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
- this只能在 “成员方法” 中使用（加引号是因为一些成员方法也不能使用this）
- 在 “成员方法” 中，this只能引用当前对象，不能再引用其他对象
- this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收
举例：
public class Student {
public String name;
public int age;
public void setStudent(Student this,String name,int age){
this.name = name;
this.age = age;
}
public void printStudent(){
System.out.println("name:" + this.name);
System.out.println("age:" + this.age);
}
public void fun(Student this){
//有没有this都能调用成员方法
this.printStudent();
}
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setStudent("zhangsan",12);
stu1.fun();
}
}在上面代码中，成员方法已经显式地将this这个参数添加，而main函数里面调用成员方法时并没有增加参数，但仍然可以运行通过
运行截图：
五、对象的构造及初始化
1.如何初始化对象
我们已知，在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败
而如果是对象没有初始化，却可以正常通过编译
代码示例：
public static void main(String[] args) {
Student stu1 = new Student();
/*stu1.setStudent("zhangsan",12);*/
/*stu1.fun();*/
stu1.printStudent();
}
//通过编译运行结果：
以上代码有两点有两点值得我们注意：
- 每次对象创建好后调setStudent方法设置具体的信息，比较麻烦，那么对象该如何初始化
- 局部变量必须要初始化才能使用，为什么字段声明之后没有赋值依然可以使用
2.构造方法
（1）概念
构造方法（也称为构造器）是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次
代码示例：
public class Data {
public int year;
public int month;
public int day;
//构造方法
//名字与类名相同，没有返回值类型，设置成void也不行
//一般情况下使用public修饰
//在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
public Data(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
System.out.println("Data(int year,int month,int day) 方法被调用");
}
public void printData(){
System.out.println(this.year + "-" + this.month + "-" + this.day);
}
public static void main(String[] args){
//此处创建了一个Data类型的对象，并没有显式调用构造方法
//输出 Data(int year,int month,int day) 被调用
Data d = new Data(2000,1,1);
d.printData();
}
}注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间
（2）特性
- 名字必须与类名相同
- 没有返回值类型，设置为void也不行
- 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
- 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
代码示例：
public class Data {
public int year;
public int month;
public int day;
//带三个参数的构造方法
public Data(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
System.out.println("Data(int year,int month,int day) 方法被调用");
}
//无参构造方法
public Data(){
System.out.println("Data() 被调用");
}
public void printData(){
System.out.println(this.year + "-" + this.month + "-" + this.day);
}
public static void main(String[] args){
//输出 Data() 被调用
Data d = new Data();
d.printData();
}
}运行结果：
上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载
- 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的
注意：一旦用户定义，编译器则不再生成（比如用户自定义了一个三个参数的构造方法，且没有构造无参的构造方法，则用户在创建对象时无法使用无参的构造方法，系统不会再自动生成一份默认的构造方法）
代码示例：
public class Data {
public int year;
public int month;
public int day;
public Data(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
System.out.println("Data(int year,int month,int day) 方法被调用");
}
//无参的构造方法被注释
/*public Data(){
System.out.println("Data() 被调用");
}*/
public void printData(){
System.out.println(this.year + "-" + this.month + "-" + this.day);
}
public static void main(String[] args){
//编译失败，报错
Data d = new Data();
d.printData();
}
}
- 构造方法中，可以通过this调用其他构造方法来简化代码
代码示例：
public class Data {
public int year;
public int month;
public int day;
public Data(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
public Data(){
this(2000,1,1);
}
public void printData(){
System.out.println(this.year + "-" + this.month + "-" + this.day);
}
public static void main(String[] args){
Data d = new Data();
d.printData();
}
}注意：
- this(...)必须是构造方法中的第一条语句
- 不能形成环
例如：
public Data(int year,int month,int day){
this();
this.year = year;
this.month = month;
this.day = day;
}
public Data(){
this(2000,1,1);
}
- 绝大多数情况使用public修饰，特殊场景下会被private修饰
3.默认初始化
在上文提到过要注意的第二个点，为什么成员变量在使用时不用初始化
要搞清楚这个问题，就需要知道new关键字背后的事情：
- 检测对象对应的类是否加载满了，如果没有加载则加载
- 为对象分配内存空间
- 处理并发安全问题（比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突）
- 初始化所分配的空间
即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如：
| 类型 |
默认值 |
| byte |
0 |
| short |
0 |
| int |
0 |
| long |
0L |
| float |
0.0f |
| double |
0.0 |
| char |
'\u0000' |
| boolean |
false |
| reference（各种引用类型） |
null |
- 设置对象头信息
- 调用构造方法，给对象中各个成员赋值
4.就地初始化
在声明成员变量时，就直接给出了初始值
代码示例：
public class Data {
public int year = 2000;
public int month = 1;
public int day = 1;
public Data(int year,int month,int day){
/*this.year = year;
this.month = month;
this.day = day;*/
}
public Data(){
/*this(2000,1,1);*/
}
public void printData(){
System.out.println(this.year + "-" + this.month + "-" + this.day);
}
public static void main(String[] args){
Data d = new Data();
d.printData();
}
}注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中
六、封装
1.封装的概念
面向对象程序三大特征：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互
2.访问限定符
Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：
| No |
范围 |
private |
default |
protected |
public |
| 1 |
同一包中的同一类 |
√ |
√ |
√ |
√ |
| 2 |
同一包中的不同类 |
√ |
√ |
√ |
|
| 3 |
不同包中的子类 |
√ |
√ |
||
| 4 |
不同包中的非子类 |
√ |
比如：
public：公开的，谁都可以看到
default：对于同一个包中公开，对其他包来说就是隐私（实际没有这个类型，只有当前面什么都不加的时候才是这种情况）
private：只有自己所在的类能使用，其他的都不行
说明：
- protected主要用在继承中
- default权限是什么都不写时的默认权限
- 访问权限除了可以限定类中成员的可见性，也可以控制类的可见性
注意：一般情况下成员变量设置为private，成员方法设置为public
3.包
（1）包的概念
在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。
在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可
（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) {
Date date = new Date();
System.out.println(date.getTime());
}
}运行结果：
- 可以使用import static导入包中静态的方法和字段
import static java.lang.Math.*;
public class Test {
public static void main(String[] args) {
double x = 20;
double y = 30;
//静态导入的方式写起来更方便一些
//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）自定义包
基本规则
- 在文件的最上方加上一个 package 语句指定该代码在哪个包中
- 包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式
- 包名要和代码路径相匹配，例如创建 com.byte.demo1 的包，那么会存在一个对应的路径 com/byte/demo1 来存储代码
- 如果一个类没有 package 语句，则该类被放到一个默认包中
常见的包：
- java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入
- java.lang.reflect:java 反射编程包
- java.net:进行网络编程开发包
- java.sql:进行数据库开发的支持包
- java.util:是java提供的工具程序包。(集合类等) 非常重要
- java.io:I/O编程开发包
七、static成员
之前在类中定义的成员变量，每个对象中都会包含一份（称之为实例变量）
1.static修饰成员变量
在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，它不属于某个具体的对象，是所有对象所共享的（静态成员变量最大特征）
【静态成员变量的特性】：
- 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
- 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
- 类变量存储在方法区当中
- 生命周期伴随类的一生（即：随着类的创建而创建，随着类的卸载而销毁）
代码示例：
public class StaticTest {
public static void main(String[] args) {
System.out.println(Student.classRoom);
// 静态成员变量可以直接通过类名访问
Student s1 = new Student("zhang san","nan",18,90.0);
Student s2 = new Student("li si","nv",18,80.0);
Student s3 = new Student("wang wu","nan",20,78.0);
// 也可以通过对象访问：但是classRoom是三个对象共享的
System.out.println(s1.classRoom);
System.out.println(s2.classRoom);
System.out.println(s3.classRoom);
}
}
class Student{
public String name;
public String gender;
public int age;
public double score;
public static String classRoom = "1401";
Student(String name,String gender,int age,double score){
this.name = name;
this.gender = gender;
this.age = age;
this.score = score;
}
}运行结果：
上述结果说明，虽然IDEA并不推荐使用对象来访问类成员，但用户自己写出来并不算错，仍然能运行
2.static修饰成员方法
一般类中的数据成员都设置为private，而成员方法设置为public，设置之后，Student类中classRoom 属性该如何在类外访问
Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的
public class StaticTest {
public static void main(String[] args) {
System.out.println(Student.returnClassRoom());
// 静态成员变量可以直接通过类名访问
Student s1 = new Student("zhang san","nan",18,90.0);
Student s2 = new Student("li si","nv",18,80.0);
Student s3 = new Student("wang wu","nan",20,78.0);
// 也可以通过对象访问：但是classRoom是三个对象共享的
System.out.println(s1.returnClassRoom());
System.out.println(s2.returnClassRoom());
System.out.println(s3.returnClassRoom());
}
}
class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "1401";
public static String returnClassRoom(){
return classRoom;
}
Student(String name,String gender,int age,double score){
this.name = name;
this.gender = gender;
this.age = age;
this.score = score;
}
}运行结果：
【静态方法特性】
- 不属于某个具体的对象，是类方法
- 可以通过对象调用，也可以通过 类名.静态方法名(...)方式调用，更推荐使用后者
- 不能在静态方法中访问任何非静态成员变量
- 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时无法传递this引用
- 静态方法无法重写，不能用来实现多态
3.static成员变量初始化
注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种：就地初始化和静态代码块初始化
- 就地初始化
就地初始化指的是：在定义时直接给出初始值
- 静态代码块初始化
八、代码块
1.代码块概念以及分类
使用{}定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：
- 普通代码块
- 构造块
- 静态块
2.普通代码块
普通代码块：定义在方法中的代码块，用法较少见
class Main{
public static void main(String[] args) {
{ //直接使用{}定义，普通代码块
int x = 10;
System.out.println("x1 = " + x);
}
int x = 100;
System.out.println("x2 = " + x);
}
}运行结果：
3.构造代码块
构造块：定义在类中的代码块（不加修饰符）。也叫：示例代码块。构造代码块一般用于初始化实例成员变量
class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
name = "zhao";
gender = "男";
age = 5;
score = 60.0;
}
public static String returnClassRoom(){
return classRoom;
}
Student(String name,String gender,int age,double score){
this.name = name;
this.gender = gender;
this.age = age;
this.score = score;
}
}4.静态代码块
使用static定义的代码块是静态代码块，一般用于初始化静态成员变量
class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
name = "zhao";
gender = "男";
age = 5;
score = 60.0;
}
//静态代码块
static {
classRoom = "1401";
}
public static String returnClassRoom(){
return classRoom;
}
Student(String name,String gender,int age,double score){
this.name = name;
this.gender = gender;
this.age = age;
this.score = score;
}
}注意事项
- 静态代码块不管生成多少个对象，其只会执行一次
- 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
- 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行（合并）
- 实例代码块只有在创建对象时才会执行
九、内部类
当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。在Java中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者成为外部类。内部类也是封装的一种体现
class OutClass{
class InnerClass{
}
}
//OutClass是外部类
//InnerClass是内部类【注意事项】
- 定义在class类名{}花括号外部的，即使是在一个文件里，都不能称为内部类
- 内部类和外部类共用同一个Java源文件，但是经过编译之后，内部类会形成单独的字节码文件
内部类的分类：
class OutClass{
//成员位置定义：未被static修饰——>实例内部类
public class InnerClass1{
}
//成员位置定义：被static修饰——>静态内部类
public static class InnerClass2{
}
public void method(){
//方法中也可以定义内部类——>局部内部类：几乎不用
class InnerClass3{
}
}
}根据内部类定义的位置不同，一般可以分为以下几种形式：
- 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)
- 局部内部类(不谈修饰符，前面无法加修饰符)、匿名内部类
注意：内部类其实日常开发中使用并不是非常多，在看一些库中的代码时候可能会遇到的比较多，日常开始中使用最多的是匿名内部类
1.内部类
在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类
（1）实例内部类
实例内部类：未被static修饰的成员内部类
public class InnerClassTest {
public static void main(String[] args) {
//要访问实例内部类中成员，必须要创建实例内部类的对象
// 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
//内部类：对象创建以及成员访问
OutClass.InnerClass1 innerClass1 = new OutClass().new InnerClass1();
//或者更清晰一点的创建方法
//先创建外部类对象，再创建实例内部类对象
//在 "outClass.new InnerClass1()" 语句中 "new InnerClass1()" 是一个整体
OutClass outClass = new OutClass();
OutClass.InnerClass1 innerClass2 = outClass.new InnerClass1();
innerClass2.methodInner();
}
}
class OutClass{
private int a;
static int b;
int c;
public void methodA(){
a = 10;
System.out.println(a);
}
public void methodB(){
System.out.println(b);
}
//实例内部类：未被static修饰
class InnerClass1{
int c;
public void methodInner(){
//在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
a = 100;
b = 200;
methodA();
methodB();
//如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
c = 300;
System.out.println(c);
//如果要访问外部类同名称成员，必须：外部类名称.this.成员名称
System.out.println(OutClass.this.c);
}
}
}【注意事项】
- 外部类中的任何成员都可以在实例内部类方法中直接访问
- 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
- 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
- 实例内部类对象必须在先有外部类对象前提下才能创建
- 实例内部类的非静态方法中包含了一个指向外部类对象的引用
- 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象
（2）静态内部类
被static修饰的内部成员类称为静态内部类
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修饰——>静态内部类
static class InnerClass2{
public void methodInner(){
// 在内部类中只能访问外部类的静态成员
// a = 100; // 编译失败，因为a不是类成员变量
b =200;
// methodA(); // 编译失败，因为methodA()不是静态类成员方法
methodB();
}
}
public static void main(String[] args) {
// 静态内部类对象创建 & 成员访问
OutClass.InnerClass2 innerClass = new OutClass.InnerClass2();
innerClass.methodInner();
}
}【注意事项】
- 在静态内部类中只能访问外部类中的静态成员（外部类的非静态成员，需要通过外部类的对象的引用才能访问）
- 创建静态内部类对象时，不需要先创建外部类对象
2.局部内部类
定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，简单了解下语法格式
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; 编译失败
}
}【注意事项】
- 局部内部类只能在所定义的方法体内部使用
- 不能被public、static等修饰符修饰
- 编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.class
- 几乎不会使用
3.匿名内部类
抽象类和接口部分详细介绍
十、对象的打印
这里说的是默认打印对象中的属性，只需要重写toString方法即可
打印测试：
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;
}
//编译器自己生成，右键点击Generate，选择toString
//当我们自己实现了一个toString之后，编译器就会调用自己的toString方法
//也可以在这个方法中写其他东西
//@Dverride是注解，帮助检查重写的代码对不对（返回值，方法名等）
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", gender='" + gender + '\'' +
", age=" + age +
'}';
//比如注释掉上面的return ,用下面的
//return "name = " + this.name + " gender = " + this.gender + " age = " + this.age;
}
public static void main(String[] args){
Person person = new Person("zhang san","男",18);
System.out.println(person);
}
}运行结果：
为什么重写toString就可以解决问题的原因：我们可以观察一下System.out.println(（对象名）)底层实现：
总结
以上就是今天要讲的内容，类和对象作为 Java 实现面向对象的基石，怎么强调它的重要性都不为过，因此更需要我们踏踏实实地把类和对象掌握，共勉