类与对象

维C泡泡

已于 2024-06-01 17:12:49 修改

阅读量1k

点赞数 24

文章标签： java 开发语言

于 2024-05-27 13:28:13 首次发布

本文链接：https://blog.csdn.net/a2844967431/article/details/139214891

版权

什么是类

class 类名(){

}

这就是最基本的一个类的格式：class是定义关键字，{}内部为主体。

类中包含的内容称为类的成员，成员又有成员变量和成员方法。

什么是成员变量/字段/属性

class Student(){
  
  public String name;
  public int age;
  public String sutNum;
  }

在类里面我们定义的元素就叫做成员变量。成员变量在类的里面，方法的外面。

什么是成员方法

class Student(){
  
  public String name;
  public int age;
  public String sutNum;
  public void run() {
           
   }
     }

其中

public void run() {
}

就是成员方法。

注意事项

类名注意采用大驼峰定义。

成员前写法统一为public。

此处写的方法不带 static 关键字。

类的实例化

调用类的过程被称为对象（类）的实例化。

这个可以用公式秒了：对象（类）名实例化后（自定义）新名 = new 对象名()

如：

 Student student = new  Student();

其中，new是实例化的关键字；

上面实例化student 存储（引用）了Stundent的地址。

实例化的赋值

 Student student = new  Student();
 student.name = "鹏杰"；
 student.age = "18"；

符号.是用来访问对象中的属性和方法的。

通过新定义的局部变量student来对引用的对象变量进行赋值，如若在类中没有赋值，那么引用对象的值就是0。

类可以多次被实例化

类可以被多次实例化。

class  Student
{
    public String name;
    public int age;
    public String sutNum;

}
public class Test {

    public static void main(String[] ages) {

        Student student1 = new Student();
        student1.name = "鹏杰";
        student1.age = 18;


        Student student2 = new Student();
        student2.name = "茂伟";
        student2.age = 19;

        System.out.println(student1.name);
        System.out.println(student1.age);
        System.out.println("===========");
        System.out.println(student2.name);
        System.out.println(student2.age);
    }

this.引用

this.在遇到形参和成员变量同名时可以在方法中中引用自己类的成员变量。

this引用指向当前对象，在成员方法中所有成员变量的操作，都是通过该引用去访问的。

class  Student1
{
    public String name;
    public int age;
    public String sutNum;

    public Student1(){
        System.out.println("不带参数的构造方法");
    }

    public Student1(String name,int age,String sutNum){
        this.name =name;
        this.age = age;
        this.sutNum = sutNum;
        System.out.println("带三个参数的构造方法");
    }
}
public class Student {

    public static void main(String[] ages) {

        Student1 student1 = new Student1();


        System.out.println("===========");

        Student1 student2 = new Student1("茂伟",19,"2021");

    }

}

注意

1. this对应类类型引用，即哪个对象调用就是哪个对象的引用类型。

2. this只能在"成员方法"中使用。

3. 在成员方法中，this只能引用当前对象，不能再引用其他对象。

4.如果没有this调用，那么就是形参给形参自己赋值，没有意义。

1.在调用对象之后，如果对象中没有构造方法，那么编译器会默认一个空的构造方法（无参数）；但是一旦有了其他构造方法，编译器不会再默认一个空的构造方法。

2.在对象中遇到同名方法后，通过传递参数来判断用哪个方法。

对象的构造以及初始化

特性

1. 名字必须与类名相同

2. 没有返回值类型，设置为void也不行

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)

4. 构造方法可以重载（以后会说）

5.在调用对象之后，如果对象中没有构造方法，那么编译器会默认一个空的构造方法（无参数）；但是一旦有了其他构造方法，编译器不会再默认一个空的构造方法。

6.在对象中遇到同名方法后，通过传递参数来判断用哪个方法。

7.可以通过this（参数，...，参数）调用简化代码。

8.this（）必须在构造方法中的第一行，不然报错。

9.不能套娃，如：

public Test(){
 this(1,2,3);
  }

public(int a,int b,int c){
 this();
  }

封装

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

拿手机举例，封装就是手机里面的零件，看不到里面的内部运作，我们只能用屏幕、充电等功能。

对类来说，就是将成员变量给改成外部不可操作的变量，只能在类中自己调用。

实现

将public改成private修饰。如：

class Student{

    private String name;
    public int age;
    public String sutNum;

}

此时我们的name就是一个被封装好的成员变量。如果我们非要在外部访问，如：

class  Student
{
    private String name;
    public int age;
    public String sutNum;
}
public class Test {

    public static void main(String[] ages) {

    Student student1 = new Student();   
    this.name = "茂伟"; 
}
}

就会出现以下报错。

但可以在方法中间接改被封装的成员变量受影响。

class  Student
{
    private String name;
    public int age;
    public String sutNum;

      public String Get(String name){
        this.name =name;
        return this.name;
    }
}
public static void main(String[] ages) {

        Student student = new Student();
        System.out.println(student.Get("张三"));

    }

访问限定符

public：谁都可以看得到,权限最宽的一个。

default: 在同一个包中都能调用，出了包用不了。

private：在自己的类中能用。

protected主要是用在继承中，继承部分再详细做笔记。

什么都不写就是默认权限default。

注意：一般情况下成员变量设置为private，成员方法设置为public。

包

包其实就是个文件夹。

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。

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

包的导入类

举例：可以使用 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());
  }
}

但是不推荐这种方法，很容易遇到同名成员变量和方法调用时候出错。

如下：

mport 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());
}

自定义包

在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包（文件）

包的命名以域名倒着创建

在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可。

可以看到，新创建的类在上面创建的包里面。

package，声明当前类在哪个包底下。

当想在其他的包中访问上面创建的包，只需要将import（这个是关键字） com.gdkj.www.类名就可以访问了。

static修饰成员方法

被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的（类变量存储在方法区当中），不依赖对象。静态成员只有一个，是被公用的，多少次重对象引用访问都只存在一个，无需实例化。

用对象引用和类目直接引用都可以直接调用（推荐类名访问）

生命周期伴随类的一生(随类的加载而创建，随类的卸载而销毁)

static关键字修饰的方法内，不能出现this、调用依赖对象的方法

不能直接使用非静态成员变量和方法，但是可以通过new对象访问。

static成员初始化

1.就地初始化（直接赋值）

2.get,set方法初始化。

3.构造方法初始化。

4.静态代码块初始化

代码块

{
    int a = 10;
    System.out.println(a);
}

这就是个简单的代码块，也叫实例代码块。

static{

}

这是静态代码块。一般用于初始化静态成员变量。

如果在一个类中出现多个静态代码块，那么就按照他们先后顺序来运行。

注意：

静态代码块最新被执行，其次是实例，再是构造代码块。同类型代码块看先后顺序；构造看调用。

运行先后：静态代码块>实例代码块>构造代码块

同类型代码块看代码块顺序

执行多次调用时，静态代码块只会在第一次时候被调用。

class  Student
{
    public Student(){
        System.out.println("不带参数的构造方法");
    }
    

    static {
        System.out.println("调用了静态代码块");

    }

    {
        System.out.println("调用了实例代码块");
    }
    
}
public class Test {

    public static void main(String[] ages) {

        Student student = new Student();
        
    }
}

以下是调用结果

对象的打印

class  Student1
{
    public String name;
    public int age;
    public String score;
    
    @Override
    public String toString() {
        
    }
}
public class Student {

    public static void main(String[] ages) {

        Student1 student1 = new Student1();
        System.out.println(student1);


    }
}

像这样，我们想打印对象中类容只能打印出其地址。

但是我们在其中加上这段后就变了：

class  Student
{
    public String name;
    public int age;
    public String score;
    
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score='" + score + '\'' +
                '}';
    }
}
public class Test {

    public static void main(String[] ages) {

        Student student = new Student();
        System.out.println(student);


    }
}

这是打印结果：

这其实就是用return返回值过来，我们也可以试试其他的

class  Student
{
    public String name;
    public int age;
    public String score;

    @Override
    public String toString() {
        return "我的舍友叫鹏";
    }
}
public class Test {

    public static void main(String[] ages) {

        Student student = new Student();
        System.out.println(student);


    }
}