【JAVA |类与对象】JAVA中的类与对象、内部类

✨✨谢谢大家捧场，祝屏幕前的小伙伴们每天都有好运相伴左右，一定要天天开心哦！✨✨ 

作者主页： 丠丠64-CSDN博客

✨✨ 帅哥美女们，我们共同加油！一起进步！✨✨ 

---

目录

一、前言

二、类

1.类的定义

2.类的实例化

3.this引用

三、对象构造与初始化

1.对象的默认值

2.对象的构造

3.构造的快捷方法

四、封装

1.访问限定符

2.包

3.自定义包

六、static成员

五、代码块

1.普通代码块

2.构造块

3.静态块

​编辑

六、对象的打印

七、内部类

1.匿名内部类

2.实例内部类

3.内部类实例化

4.静态内部类

---

一、前言

(Object Oriented Program）面对对象的编程语言， 面 向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情，在解决问题这一过程中，不太注重于问题的过程，更注重于结果

---

二、类

类是自定义类型，就是类似一种模型，对一个实体来进行描述，实例化出的对象 占用实际的物理空间，存储类成员变量

---

1.类的定义

在 java 中定义类时需要用到 class 关键字 ，具体语法如下 // 创建类 class ClassName { field ; // 字段 ( 属性 ) 或者 成员变量 method ; // 行为 或者 成员方法 } class为定义类的的关键字 ， ClassName 为类的名字， {} 中为类的主体

class Student {//成员属性    public String name;    public int age;    public String sex,//成员方法    public void input Student(){        System. out. println("该学生的名字:"+ this.name +"()"+ this.sex + "->"+ this.age);    }    public void Doclass(){        System. out.println(this.name +"按时上课");    }    public void DoHomework(){        System.out.println(this.name +"按时完成作业");    }    public void Exam(){        System.out.println(this.name +"诚心考试");    }}

这就是一个关于描述学生的一个类，里面有成员属性以及成员方法，而在一般的文件中往往只定义一个类

---

2.类的实例化

使用类创建一个对象的过程就称为类的实例化，可以理解为定义了一个新的类型，在java中采用new关键字，配合类名来实例化对象

Student stul = new Student():Student stu2 = new Student();stul.age = 18;stul.name="小明";stul.sex="男";stul.input Student();stul.DoClass();stul.Exam();stu1.DoHomework();stul.age = 15;stul.name ="小美";stul.sex="女";stul.input Student();stul.DoClass();stul.Exam();stul.DoHomework();

上述就为new 关键字用于创建一个对象的实例化了两个对象，使用点来访问对象中的属性与方法，同一个类可以创建对个实例。

---

3.this引用

为什么上面要用this引用呢，我们来看个案例

class Date{    public int year;    public int month,    public int day;    public void SteDay(int year,int mmonth, int day){//设置哪个对象        year = year;        month = month;        day = day;    }    public void printDate(){        System.out.println(year +"/"+ month +"/"+ day); //打印哪个对象    }}

当形参名字与成员变量名字相同时，赋值的主体和客体就不清楚了，所以就是要限定一下，

this 引用指向当前对象 ( 成员方法运行时调用该成员方法的对象 ) ，在成员方法中所有成员变量的操 作，都是通过该引用去访问，说白了就是为了限定这个这个类的这个属性

class Date{    public int year;    public int month;    public int day;    public void SteDay(Date this,int year,int mmonth, int day){//date this 为隐藏属性        this.year = year;        this.month = month;        this.day = day;    }    public void printDate(Date this){        System.out.println(this.year + "/"+ this.month + "/"+ this. day);    }}

我们可以发现地址this所引用的对象与实参的地址是相同的，说明指向了同一对象

 加上this引用可以避免很多错误，很好的代码习惯，可以培养一下这个习惯

---

三、对象构造与初始化

1.对象的默认值

前面我们学过在JAVA中的对象定义好了以后，必须进行初始化以后才可以使用，不然会报错，但是在类中的变量，定义好以后，并不会报错，因为它都会有一个默认值，对象空间被申请好之后，对象中包含的成员已经设置好了初始值

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

---

2.对象的构造

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

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;        System. out. println("调用了Date(int,int,int)这个方法");    }    public Date(int year,int month){    //带二个参数的构造方法        this.year = year;        this.month = month;        System. out.println("调用了Date(int,int)这个方法");    }    public Date(int year){    //带一个参数的构造方法        this.year = year;        System. out.println("调用了Date(int)这个方法");    }    public Date(){    //不带参数的构造方法        System. out.println("调用了Date()这个方法");    }}

构造方法的作用是对对象初始化，并不对其开辟空间，并且构造方法时候可以重载，名字相同参数不同，构成了方法的重载，但值得一提的是，当我们没有自己任何构造，JAVA会默认生成一份无参的构造方法，一旦用户构造了一种方法，则编译器不会再生成

---

当然也可以使用this调用其他构造方法来简化代码

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;        System.out.println("调用了Date(int,int,int)这个方法");    }    public Date(){        this(2004,8,24)        System. out.println("调用了Date()这个方法");    }}

public class Test    public static void main(String[] args){        Date d= new Date();        d.printDate();    }}

在用this调用的时候有几个注意的事项，this语句必须位于构造方法的第一条不然会报错，调用的方法必须构造方法中的其中一个，不能相互调用形成环编译器会报错。

---

构造方法的类型是由顺序决定的，好比从上到下d1为三个参数的构造方法，后面的所有构造方法均为三个参数的构造方法，就像出生一样，整个对象的生命周期内只调用一次，输入不符合的参数就会报错

Date dl= new Date(2004,8,24);d1.printDate();Date d2 = new Date(2004,8);d2.printDate();Date d3 = new Date(2004);d3.printDate();Date d4 = new Date();d4.printDate();

---

3.构造的快捷方法

如果一个类中的属性很多，我们不好去一条条写出来方法，我们就可以使用快捷方法来自动生成方法，只需要写好成员属性

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

点点鼠标就可以生成这些代码，使我们需要的时候调用方法就行，会很方便

---

四、封装

什么是封装，就好比一个东西的实现不用在乎里面发生了什么，只在乎能干什么，用套壳来屏蔽细节，只告诉用户能干什么，更体现了面对对象这一思想

---

1.访问限定符

JAVA中主要使用类访问限制权限来实现封装，类可以将数据以及封装数据的方法结合在一起，访问权限用来控制方法或者字段能否直接在类外使用

	范围	private	default	protected	public
1	同一包同一类	√	√	√	√
2	同一包不同类		√	√	√
3	不同包的子类			√	√
4	不同包的非子类				√

---

2.包

就是为了更好的管理，将多个类整合在一起成为一组，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，在同一个工程中允许存在相同名称的类，只要处在

不同的包中即可

---

Java 中已经提供了很多现成的类供我们使用，使用import语句导入包

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

如果要使用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 java.util.*;import java.sql.*;public class Test {    public static void main(String[] args){        java.until.Date data = new java.util.Date();/! 得到一个亳秒级别的时间戳        System.out.println(date.getTime());    }}

---

3.自定义包

在文件的最上方加上一个 package 语句指定该代码在哪个包中 . 包名需要尽量指定成唯一的小写名字 , 通常会用颠倒形式 ( 例如 com.xian.www  ). 这样就创建好了一个包

---

六、static成员

我们上述说的都属于非静态成员，如果一个类中的某个成员属性都是共用的，就不需要依靠对象。

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

class Student {//非静态属性    public String name;    public int age;    public String sex;//静态属性    public static String classroom="109";}

public class Test    public static void main(String[] args)        Student stul = new Student()        Student stu2 = new Student()        stul.age = 18;        stul.name="小明";        stul.sex="男";        stul.age = 15;        stul.name = ="小美";        stul.sex="女";    }}

我们发现我们所定义的 静态成员变量并没有存储到某个具体的对象，而是属于类的属性，可以通过类来访问

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

---

五、代码块

1.普通代码块

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

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

                {

                        //这就是一个代码块   { }扩起来的部分

                }

        }

}

---

2.构造块

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

class Student{    public String name;    public int age;    public String sex;    public static int classroom;    public Student(){        System. out.println("构造方法");        this.name = "liming";        this.age = 12;        this.sex="man";        System.out.println("实例代码块");    }    statici{        classroom= 109;        System.out.println("实例静态代码块");    }    public void input_Student(){        System. out.println("该学生的名字:"+ this.name + "()" + this.sex + "->" + this.age);    }}

---

3.静态块

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

• 静态代码块不管生成多少个对象，其只会执行一次
• 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行
• 实例代码块只有在创建对象时才会执行

  ---

  最后从结果我们可以得出结论，在执行代码过程中，实现的先后顺序应该是

  静态代码块 > 代码块 > 构造方法 

  ---

  六、对象的打印

  我们使用重写 toString 方法即可打印出类中的属性，很方便

  @Overridepublic String toString(){    return "Student {" + name = "+ name + "age = " + age + "sex = " + sex + "}"}

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

  这样就可以直接打印出来

  ---

  七、内部类

  将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类 public class OutClass {         class InnerClass {         } } // OutClass 是外部类 // InnerClass 是内部类

  1.匿名内部类

  我们构造了一个接口A，在Test5类内部中重写A，这样的就叫做匿名内部类

  interface A{    void test();}public class Test5 {    public static void main(String[] args){        new A(){            @Override            public void test() {                System.out.println("hehehhehehehheheheh");            }        }.test();    }}

  2.实例内部类

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

  public class OutClass {    class InnerClass{    }}

  ---

  外部类中的任何成员都可以在实例内部类方法中直接访问

  public class OutClass {    public int num1 = 1;    static int num2 = 2;    class InnerClass{        int num3 = 3;        public void methodInner(){            num1 = 100;            num2 = 200;            System.out.println(num1);            System.out.println(num2);        }    }}

  ---

  在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员， 必须：外部类名称.this. 同名成员来访问

  public class OutClass {    int num3 = 3;    class InnerClass{        int num3 = 3;        public void methodInner(){                       num3 = 300;                 System.out.println(num3); //优先访问自己内部的            System.out.println(OutClass.this.num3);    //加外部类名加this是外部        }    }

  ---

  3.内部类实例化

  实例内部类对象必须在先有外部类对象前提下才能创建， 不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

  OutClass.InnerClass innerClass = new OutClass().new InnerClass();innerClass.methodInner();

  ---

  4.静态内部类

  被static修饰的成员内部类

  public class OutClass {    static class InnerClass{    }}

  ---

  静态内部类内部只能访问外部类的静态成员

  public class OutClass {    public int num1 = 1;    static int num2 = 2;        static class InnerClass{             public void methodInner(){            num1 = 100;            num2 = 200;                        System.out.println(num1);            System.out.println(num2);        }    }}

  我们可以发现访问非静态成员会报错

  ---

  创建静态内部类对象时，不需要先创建外部类对象

  OutClass.InnerClass innerClass = new OutClass.InnerClass();innerClass.methodInner();

  ---

  希望对你有用