Java类和对象【详解】

最新推荐文章于 2024-05-18 23:12:19 发布

脑袋困掉了...

最新推荐文章于 2024-05-18 23:12:19 发布

阅读量227

点赞数 2

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_62884277/article/details/127825742

版权

Java-类和对象

一、面向对象的初步认知
- 1.1 面向对象和面向过程
二、类的定义和使用
- 2.1 类的定义格式
三、类的实例化
- 3.1 什么是实例化
- 3.2 类和对象的说明
四、this引用
五、对象的构造
六、 static关键字
七、代码块
- 7.1 代码块概念以及分类
八、内部类

一、面向对象的初步认知

什么是面向对象

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

1.1 面向对象和面向过程

面向对象： 将问题分解成一个一个步骤，对每个步骤进行相应的抽象，形成对象，通过不同对象之间的调用，组合解决问题。

面向过程： 把问题分解成一个一个步骤，每个步骤用函数实现，依次调用即可。

注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有哪个好坏之分，都有其专门的应用场景。

二、类的定义和使用

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干什么)，描述完成后计算机就可以识别了

比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。
属性：产品品牌，型号，产品重量，外观尺寸，颜色…
功能：洗衣，烘干、定时…

那么，在Java语言中，如何对上述的洗衣机类来进行定义呢？

2.1 类的定义格式

在java中定义类时需要用到class关键字，具体语法如下：

// 创建类
class ClassName{
   &emsp;&emsp;&emsp; field; // 字段(属性) 或者 成员变量
   &emsp;&emsp;&emsp; method; // 行为 或者 成员方法
 }

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

注意事项：

类名注意采用大驼峰定义
成员前写法统一为public
此处写的方法不带 static 关键字

例子：定义一个洗衣机类

class WashMachine{
   public String brand; // 品牌
   public String type; // 型号
   public double weight; // 重量
   public double length; // 长
   public double width; // 宽
   public double height; // 高
   public String color; // 颜色

   public void washClothes(){ // 洗衣服 
   System.out.println("洗衣功能"); 
   }

   public void dryClothes(){ // 脱水
   System.out.println("脱水功能"); 
   }

   public void setTime(){ // 定时
   System.out.println("定时功能"); 
   }
 }

注意事项：

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

三、类的实例化

3.1 什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

例如：实例化一个狗类

class PetDog {
public String name;//名字
public String color;//颜色 

// 狗的属性
public void barks() { 
System.out.println(name + ": 旺旺旺~~~"); 
}

// 狗的行为
public void wag() { 
System.out.println(name + ": 摇尾巴~~~");
 } 
}

public class Main{
public static void main(String[] args) { PetDog dogh = new PetDog(); //通过new实例化对象
dogh.name = "阿黄";
dogh.color = "黑黄";
dogh.barks();
dogh.wag();

PetDog dogs = new PetDog();
dogs.name = "阿黄";
dogs.color = "黑黄";
dogs.barks();
dogs.wag();
 } 
}

输出结果：
阿黄: 旺旺旺~~~
阿黄: 摇尾巴~~~
赛虎: 旺旺旺~~~
赛虎: 摇尾巴~~~

注意事项：

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

3.2 类和对象的说明

类（class）和对象 (object)是两种以计算机为载体的计算机语言的合称。 对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型。

1.类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.

2.类是一种自定义的类型，可以用来定义变量.

3.一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

4.做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

四、this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

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(this.year + "/" + this.month + "/" + this.day); 
 } 
}

注意：this引用的是调用成员方法的对象。

this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
this只能在"成员方法"中使用
在"成员方法"中，this只能引用当前对象，不能再引用其他对象
this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收

五、对象的构造

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

public class Date {
public int year;
public int month;
public int day; 
// 构造方法： 
// 名字与类名相同，没有返回值类型，设置为void也不行
// 一般情况下使用public修饰 
// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
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 void printDate(){
 System.out.println(year + "-" + month + "-" + day); 
}

public static void main(String[] args) { 
// 此处创建了一个Date类型的对象，并没有显式调用构造方法 
 Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
 d.printDate(); // 2021-6-9
  } 
}

特性：

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

六、 static关键字

6.1 static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

public class Student{
public String name;
public String gender;
public int age;
public double score;
public static String classRoom = "Bit306"; // ...
public static void main(String[] args) {
 // 静态成员变量可以直接通过类名访问
  System.out.println(Student.classRoom); 
   
  Student s1 = new Student("Li leilei", "男", 18, 3.8);
  Student s2 = new Student("Han MeiMei", "女", 19, 4.0); 
  Student s3 = new Student("Jim", "男", 18, 2.6); 

 // 也可以通过对象访问：但是classRoom是三个对象共享的
  System.out.println(s1.classRoom);
  System.out.println(s2.classRoom);
  System.out.println(s3.classRoom);
 } 
}

【静态成员变量特性】

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

6.2 static修饰成员方法

被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过
静态方法来访问的。

public class Student{ 
// ...
private static String classRoom = "Bit306";
 // ...
public static String getClassRoom(){ 
return classRoom; 
 } 
}

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

【静态方法特性】

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

6.3 static成员变量初始化

静态成员变量的初始化分为两种：就地初始化和静态代码块初始化。

1. 就地初始化： 在定义时直接给出初始值

public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bit306"; 
// ...
}

2. 静态代码块初始化

那什么是代码块呢？继续往后看 😃 ~~~

七、代码块

7.1 代码块概念以及分类

使用 {} 定义的一段代码称为代码块。

根据代码块定义的位置以及关键字，又可分为以下四种：

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

public class Main{
public static void main(String[] args) { 
{ //直接使用{}定义，普通方法块
 int x = 10 ;
  System.out.println("x1 = " +x); 
  }
  int x = 100 ; 
  System.out.println("x2 = " +x);
   } 
 }
  // 执行结果 
  x1 = 10
  x2 = 100

这种用法比较少见

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

public class Student{ 
//实例成员变量
private String name;
private String gender;
private int age;
private double score;
public Student() { 
System.out.println("I am Student init()!");
 }
 
 //实例代码块 
 { this.name = "a"; 
 this.age = 12;
  this.sex = "man"; 
  System.out.println("I am instance init()!"); 
  }
  
public void show(){
 System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
 } 
}
public class Main {
public static void main(String[] args) { 
Student stu = new Student(); 
stu.show(); 
 } 
}
// 运行结果
 I am instance init()! 
 I am Student init()! 
 name: a age: 12 sex: man

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

public class Student{
   private String name;
   private String gender;
   private int age;
   private double score;
   private static String classRoom; 
   //实例代码块 {
   this.name = "a"; 
   this.age = 12;
   this.gender = "man";
   System.out.println("I am instance init()!"); 
   }
   
   // 静态代码块 
   static {
  classRoom = "bit306";
  System.out.println("I am static init()!");
   }
   
   public Student(){ 
   System.out.println("I am Student init()!"); 
   }
   
   public static void main(String[] args) { 
   Student s1 = new Student(); 
   Student s2 = new Student();
   } 
 }