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

丠丠64

已于 2024-06-11 15:15:10 修改

阅读量1.2k

点赞数 51

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

于 2024-05-21 11:48:55 首次发布

本文链接：https://blog.csdn.net/YKX0000/article/details/139075761

版权

Java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

✨✨谢谢大家捧场，祝屏幕前的小伙伴们每天都有好运相伴左右，一定要天天开心哦！✨✨
🎈🎈作者主页： 🎈丠丠64-CSDN博客🎈

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

一、前言

(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 方法即可打印出类中的属性，很方便

@Override
public 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();

希望对你有用

丠丠64

关注

51
点赞
踩
26

收藏

觉得还不错? 一键收藏
3
评论
【JAVA |类与对象】JAVA中的类与对象、内部类

在java中定义类时需要用到class关键字，具体语法如下//创建类classClassNamefield;//字段属性或者成员变量method;//行为或者成员方法class为定义类的的关键字ClassName为类的名字，{}中为类的主体这就是一个关于描述学生的一个类，里面有成员属性以及成员方法，而在一般的文件中往往只定义一个类在文件的最上方加上一个package语句指定该代码在哪个包中包名需要尽量指定成唯一的小写名字通常会用颠倒形式例如。
复制链接

扫一扫

专栏目录