Java类与对象(汇总版)，心血作品，走过路过不要错过

echo_lwh

已于 2022-08-19 16:50:37 修改

阅读量241

点赞数 17

文章标签： java 开发语言

于 2022-08-18 23:50:32 首次发布

本文链接：https://blog.csdn.net/m0_48064834/article/details/126184710

版权

1.Java中类定义和使用

//创建类

class Class Name

field; // 字段(属性)或者成员变量

method; // 行为或者成员方法

}

public class Student1 {
    //字段（属性）或成员变量
    public String name;
    public String gender;
    public double score;
    
    //行为 或者 成员方法
    public void DoClass(){
        
    }
    public void DoHomework(){
        
    }
    public void Exam(){
        
    }
}

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

2.类的实例化

2.1什么是实例化

定义了一个类相当于定义了一个新的数据类型，与int，double类似。用类类型创建对象的过程，成为类的实例化。

class Student {
    //字段（属性）或成员变量
    public String name;
    public String gender;
    public double score;

    //行为 或者 成员方法
    public void DoClass(){
        System.out.println(name + "正在上课");
    }
    public void DoHomework(){
        System.out.println(name + "正在写作业");
    }
    public void Exam(){
        System.out.println(name + "考试结果为" + score);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
    }
}

2.2访问类中的属性和方法

class Student {
    //字段（属性）或成员变量
    public String name;
    public String gender;
    public double score;

    //行为 或者 成员方法
    public void DoClass(){
        System.out.println(name + "正在上课");
    }
    public void DoHomework(){
        System.out.println(name + "正在写作业");
    }
    public void Exam(){
        System.out.println(name + "考试结果为" + score);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.name = "echo";
        student1.gender = "female";
        student1.score = 96.5;
        student1.DoClass();
        student1.DoHomework();
        student1.Exam();
        //Student student2 = new Student();
    }
}

2.3成员变量的默认值

class Student {
    //字段（属性）或成员变量
    public String name;
    public String gender;
    public double score;
    public boolean boy;

    //行为 或者 成员方法
    public void DoClass(){
        System.out.println(name + "正在上课");
    }
    public void DoHomework(){
        System.out.println(name + "正在写作业");
    }
    public void Exam(){
        System.out.println(name + "考试结果为" + score);
    }
    public void Show(){
        System.out.println("名字：" + name + "性别: " + gender + "成绩: " + score + "是不是男孩: " + boy);
    }
}

public class TestDemo {
    public static void main(String[] args) {
       Student student1 = new Student();
       student1.Show();
       
    }

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

4. 当成员变量没有初始化值的时候，每个成员变量都是它对应的0值

5. 引用类型对应的值是null

6. boolean类型对应的是false

7. char对应的是一个空格

3.this引用

3.1为什么要用this引用

当形参名不小心与成员变量名相同时：

public class Date {
    public int year;
    public int month;
    public int day;
    public void setDay(int year, int month, int day){
        year = year;
        month = month;
        day = day;
    }
    public void printDate(){
        System.out.println(year + "/" + month + "/" + day + "/");
    }

    public static void main(String[] args) {
        Date d1 = new Date();
        d1.setDay(2022,8,16);
        d1.printDate();
    }
}

应该怎么修改呀

public class Date {
    public int year;
    public int month;
    public int day;
    public void setDay(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 d1 = new Date();
        d1.setDay(2022,8,16);
        d1.printDate();
    }
}

调试一下

若是没加this，同样调试程序

通过调试对比，我们发现this代表当前对象的引用

此外，本质上this是一个隐式参数

到目前为止，this的作用有：

1. 代表当前对象的引用

2. 当形参名不小心与成员变量名相同时，可以区别形参名与成员变量名

3. this本质上来说，是一个隐式的参数

3.2this引用特性

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
2. this只能在"成员方法"中使用
3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责调用成员方法，对象的引用传递给该成员方法，this负责接收

3.3this的用法

1. this.data //访问成员变量

2. this.fun( ) //访问成员方法

3. this( ) //调用本类中的其他构造方法

4.对象的构造及初始化

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

构造方法的特点：

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

5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

比如

由此可以发现，在实例化对象时，会调用一个不带参数的构造方法。但有时候，我们并没有写构造方法，但是也能运行成功，这是为什么呢？

1. 当程序中没有构造方法时，编译器会自己生成一个不带参数的构造方法

2. 当自己写了一个构造方法时，就不会生成构造方法，这就使得，如果写了构造方法，就必须写一个不带参数饿构造方法

多个构造方法之间形成重构

4.3创建构造方法的快捷键

鼠标右键-->Generate-->Constructor-->按住control(苹果是fn上面的键)，选中要作为参数的成员变量。

4.4this调用构造方法

1.this( )调用本类中构造方法时，必须放在第一行

2.不能形成环

 public Student(){
        this("hello");
        System.out.println("这个是不带参数的构造方法！");
    }
    public Student(String s){
        System.out.println(s);
    }
}

public class TestDemo {
    public static void main(String[] args) {
       Student student1 = new Student();
}

4.5初始化对象

1.就地初始化

2.不初始化

3.类外初始化

4.通过构造方法初始化

5.成员变量的打印

class Student {
    //字段（属性）或成员变量
    public String name;
    public String gender;
    public double score;
    public boolean boy;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", score=" + score +
                ", boy=" + boy +
                '}';
    }
}

public class TestDemo {
    public static void main(String[] args) {
       Student student1 = new Student();
        System.out.println(student1);
}

鼠标右键-->Generate-->toString-->按住control(苹果是fn上面的键)，选中要作为参数的成员变量。

6.封装

面向对象程序的三大特性：封装，继承，多态。

6.1.public和private的区别

class Student {
    private int age;
    private double score;
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
public class TestDemo {
    public static void main(String[] args) {
       Student student1 = new Student();
        student1.setName("echo");
        String name = student1.getName();
        System.out.println(name);
}

6.2成员变量接口的提供，快捷键

鼠标右键-->Generate-->Getter and setter-->按住control(苹果是fn上面的键)，选中要作为参数的成员变量。

6.3包访问权限(默认权限)

6.3.1 什么是包

1.为了更好的管理，把多个类手机在一起成为一组，成为软件包

2.在Java中，包是对类的接口等的封装机制的体现，是一种对类或者接口等的良好的组织形式

3.包还有一个重要的作用，早同一个工程中循序存在相同名称的类，只要在不同的包中就行

6.3.2导入包中的类

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

public class TestDemo {
    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 TestDemo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

当需要导入多个包时，如果一个一个导入，也可能比较麻烦，所以可以用*表示导入所有的包：

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

但是也存在调用的包里面会有名称相同的类，此时编译器就不知道用哪一个包中的类

6.3.3如何自定义包

1.创建包的步骤

2.控制包文件的显示模式：

3.调用自定义包：

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

6.3.4包访问权限

在同一个包中访问a时：

在别的包中访问a时：

通过上面的范例可以知道，包访问权限的变量只能在同一个包中访问，在不同包中就会访问受限。

6.3.5 public，private，默认全职的权限总结

6.3.6常见的包

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编程开发包

7. static成员

7.1static修饰成员变量和成员方法

未用static修饰成员变量时

用static修饰成员变量

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

2.Java中，被static修饰的成员方法称为静态成员方法，是类的方法，是不某个对象所特有的

7.2类变量和类方法

字段/属性/成员变量

1.普通成员变量

2.静态成员变量，又叫类变量

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

方法/成员方法

1.普通成员方法

2.静态成员变量，又叫类方法

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

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

7.静态方法无法重写，不能用来实现多态

7.3访问类方法和类变量

1.可以通过对象调用，也可以通过类名。静态方法名(...)方式调用，更推荐使用后者

class Student{
    public String name;
    public int age;
    public  double score;
    public static String classes;
   // public  String classes;
    public static void doClass(){
        System.out.println("正在上课");
    }
}
public class Test2 {
    public static void main(String[] args) {
    Student student2 = new Student("echo",29,92.0);
        System.out.println(student2);
        student2.classes = "bit106";//通过对象调用
        Student.doClass();//通过类名.静态方法名()方式调用
        Student.classes = "bit105";//通过类名.静态变量 方式调用
    }
}

7.4解释一个现象——之前写的函数都用static修饰

之前用static修饰时，在main中直接用函数名就可以调用func函数

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

若未用static修饰，在main中不可以直接用函数名就可以调用func函数

public class Test {
    public void func(){

    }
    public static void main(String[] args) {
        Test.func();
    }
}

分析：应为main函数是被static修饰的，所以main的使用不依赖对象

1.如果在main里面调用的方法也是被static修饰，即也不依赖于对象，此时就可以直接调用

2.如果在main里面调用非静态成员时，因为非静态成员以来于对象，所以此时就得实例化一个对象

8.代码块

8.1代码块概念以及分类

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

普通代码块：一般不会用

构造块或者实例代码块：一般用来初始化普通成员变量

静态块：一般用于初始化静态的数据

同步代码块（后续讲解多线程部分在谈）

class Student{
    public int a;
    public int b;

    public int c;
    public static int d;
    public static int e;
    public static int f;
    {
        System.out.println("这是一个实例代码块");
         a = 10;
         b = 20;
         c = 30;
    }

    public Student(){
        System.out.println("这是一个构造方法");
    }
    static{
        System.out.println("这是一个静态代码块");
        d = 10;
        e = 20;
        f = 30;
    }

}
public class Test1 {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

优先级：静态代码块 > 实例代码块>构造方法

当有多个静态代码块时，运行的先后顺序有代码的先后顺序决定

9.内部类

内部类就相当于外部类的一个成员，实例内部类就相当于普通成员，其依赖于对象。

静态内部类就相当于静态成员，其不依赖于对象

9.1内部类的分类

有实例内部类和静态内部类

9.2实例内部类

实例内部类的问题总结：

1.如何实例化内部对象

2.实例内部类中不能定义静态的成员变量。原因：实例内部类是需要实例化外部类对象才能访问的。那么非要定义的话，可以加final，将该变量变为常量

3.当内部类和外部类变量重名了，怎么办？优先使用内部类自己的变量。那么如何拿到外部类的变量呢？

4.在实例内部类当中不能定义静态方法，因为实例内部类是依赖对象的，当没有外部类对象时，内部类这个类是不存在的，当类不存在时，当然也就不能访问其中的静态方法

注意事项：

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

class  OuterClass1{
    public int data1 = 10;
    public int data2 = 20;
    public static int data3 = 30;

    //实例内部类
    class InnerClass{
        public int data1 = 1000;
        public int data5 = 50;
        //在实例内部类定义静态的成员变量
        public static final int data6 = 60;

        public InnerClass(){
            System.out.println("InnerClass1的构造方法！");
        }
        public void method(){
            System.out.println(data1);
            System.out.println(this.data1);
            //在实例内部类当中访问重名的外部类的成员变量
            System.out.println(OuterClass1.this.data1);
            //可以意识到，在实例内部类当中，不仅包含了自己的this，而且包含了外部类的this
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("InnerClass的一个method方法");
        }
    }
    public void methodOut(){
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.data1);
    }
}

public class Test2 {
    public static void main(String[] args) {
        //实例化方法1：
        OuterClass1 outerClass = new OuterClass1();//实例内部类
        //外部类名.内部类名——拿到内部类的类型
        OuterClass1.InnerClass innerClass = outerClass.new InnerClass();

        //实例化方法2：
        OuterClass1.InnerClass innerClass1 = new OuterClass1().new InnerClass();
        innerClass.method();
    }
}

9.3静态内部类

静态内部类中的问题总结：

1.如何实例化静态的内部：静态的成员不依赖以对象

2.在静态内部类当中，只能访问外部类的静态成员变量。但是如果非要访问外部类的非静态变量，那么怎么访问？方法：在静态呢不类中实例化一个对象或者传入一个对象

class  OuterClass{
    public int data1 = 10;
    public int data2 = 20;
    public static int data3 = 30;

    //静态内部类
    static class InnerClass{
        public int data4 = 40;
        public int data5 = 50;
        public static int data6 = 60;
        //2.在静态实例内部类中，只能访问外部类的静态成员变量，但是如果非要访问外部类的非静态变量，那么怎么访问？
        //public static final int data6 = 60;
        OuterClass out = new OuterClass();
        InnerClass(){
            System.out.println("InnerClass1()");
        }
        public void method(){
            System.out.println(out.data1);
            System.out.println(out.data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("InnerClass的method");
        
        }
    }


public class Test3 {
    public static void main(String[] args) {
        //在实例化内部类之前并不需要实例化外部类，也不用实例化内部类
        OuterClass.InnerClass.data6 = 10;//访问内部类的静态成员变量

        //1、如何实例化静态的内部
        //在实例化内部类之前并不需要实例化外部类
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();//拿到实例内部类的对象

    }
}