Java全面细致讲解类与对象

类和对象的关系

类就是一类对象的统称。对象就是这一类具体化的一个实例。 （对象是类的实例化）

对象是什么？

此对象非彼对象！！！说到对象就要提到过程。

面向过程：C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。

面向对象：JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来 。

只能说这样解释起来很抽象，举个冰箱的例子。

面向过程：1.把冰箱打开 2. 把水果放入 3. 冰箱关起来

面向对象：冰箱。 打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

总结：面向对象就是用代码(类)来描述客观世界的事物的一种方式。一个类主要包含一个事物的属性和行为。

 

类和对象的实例化

怎么创建一个类：

// 创建类
class < class_name > {
field ; // 成员属性
method ; // 成员方法
}
// 实例化对象
< class_name > < 对象名 > = new < class_name > ();
（类名称采用大驼峰命名方式）

举个例子：

public class TestModer {
  public static void main(String[] args) {
      Person person1 = new Person();
      person1.name = "张三";
      person1.age = 18;
      System.out.println(person1.name);
      System.out.println(person1.age);
      person1.eat();
      Person person2 = new Person();
      person2.name = "李四";
      person2.age = 20;
      System.out.println(person2.name);
      System.out.println(person2.age);
      person2.eat();
  }
}
  class Person {
      public String name;
      public int age;

      public void eat() {
          System.out.println("吃饭");
      }
  }

类中定义的变量可称为“字段”/“属性”/“成员变量”，类中定义的方法叫成员方法，我们可以知道一个类可以实例化多个对象，每个对象都有一个普通成员变量。

用类类型创建对象的过程，称为类的实例化

1. 类只是 一个 模型 一样的东西，限定了类有哪些成员 。

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

 

static关键字

成员变量分为普通成员变量和静态成员变量两种，普通成员变量上面已经说过了-->public String name;name就是普通成员变量，而用static修饰之后，就成为了静态成员变量。public static String name，name就成为了静态成员变量。下面来看个例子：

public class TestModer {
  public static void main(String[] args) {
      Person person1 = new Person();
      person1.age ++;
      Person.high++;
      System.out.println(person1.age);
      System.out.println(Person.high);
      Person person2 = new Person();
      person2.age++;
      Person.high++;
      System.out.println(person2.age);
      System.out.println(Person.high);
  }
}
  class Person {
      public int age;
      public static int high;
      public void eat() {
          System.out.println("吃饭");
      }
  }

注意：静态成员变量不可以放在其他方法中定义，静态变量属于类，不属于对象。

默认值：

static修饰的成员变量叫静态成员变量，static修饰的方法成为静态方法。

1、静态方法属于类，而不属于类的对象。

2、可以直接调用静态方法，而无需创建类的实例。

3、静态方法可以访问静态数据成员，并可以更改静态数据成员的值

4、静态方法内部不可以调用其他方法，但是其他方法内部可以调用静态方法。

看个例子：

    public static void main(String[] args) {
      Test.change();//无需创建实例对象 就可以调用
      System.out.println(Test.count);
  }
}
class Test{
  public int a;
  public static int count;

  public static void change() {
      count = 100;
      //a = 10; error 不可以访问非静态数据成员
  }
}

//结果为100

 

private实现的封装

什么叫封装：

<< 代码大全 >> 开篇就在讨论一个问题 : 软件开发的本质就是对程序复杂程度的管理 . 如果一个软件代码复杂程度太高 , 那么就无法继续维护 。 如何管理复杂程度 ? 封装就是最基本的方法 。 在我们写代码的时候经常会涉及两种角色 : 类的实现者 和 类的调用者 . 封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的 , 只要知道如何使用类就行了 .这样就降低了类使用者的学习和使用成本 , 从而降低了复杂程度。

private实现的封装：

private/ public 这两个关键字表示 " 访问权限控制 " .

被 public 修饰的成员变量或者成员方法 , 可以直接被类的调用者使用 .

被 private 修饰的成员变量或者成员方法 , 不能被类的调用者使用 .

换句话说 , 类的使用者根本不需要知道 , 也不需要关注一个类都有哪些 private 的成员 。 从而让类调用者以更低的 成本来使用类。

看个例子：

public class TestModer {
  public static void main(String[] args) {
      Person person = new Person();
      person.show();
  }
}
class Person{
  private String name = "张三";
  private int age = 18;
  public void show() {
      System.out.println("我叫" + name + ", 今年" + age + "岁");
  }
}

此时字段已经使用 private 来修饰 . 类的调用者 (main 方法中 ) 不能直接使用 . 而需要借助 show 方法。 此时类的使用者就不必了解 Person 类的实现细节。 同时如果类的实现者修改了字段的名字 , 类的调用者不需要做出任何修改 ( 类的调用者根本访问不到 name, age 这样的字段 )。

注意：

1、private 不光能修饰字段 , 也能修饰方法

2、通常情况下我们会把字段设为 private 属性 , 但是方法是否需要设为 public, 就需要视具体情形而定。 一般我们希 望一个类只提供 " 必要的 " public 方法 , 而不应该是把所有的方法都无脑设为 public。

现在有一个问题 类的实现者万一修改了 public 方法 show 的名字 , 岂不是类的调用者仍然需要大量修改代码 嘛 ?

这个时候我们就来看看 getter 和 setter 方法。

getter 和 setter 方法的使用：

public class TestModer {
  public static void main(String[] args) {
      Person person = new Person();
      person.setName("张三");
      String name = person.getName();
      System.out.println(name);
      person.show();
  }
}
class Person{
  private String name;//实例成员变量
  private int age;
  public void setName(String name){
      //name = name;//不能这样写
      this.name = name;//this引用，表示调用该方法的对象
  }
  public String getName(){
      return name;
  }
  public void show(){
      System.out.println("name: "+name+" age: "+age);
  }
}

字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用，这时候我们可以借助getter和setter来使用，getName 即为 getter 方法, 表示获取这个成员的值。setName 即为 setter 方法, 表示设置这个成员的值。getter和setter可以不用手动输入，可以在类中点击右键按下图操作：

在这里我们是调用了show这个方法来实现打印，如果不调用方法，可以自带的to String进行打印。

to String用法：

public class TestModer {
      public static void main(String[] args) {
          Person person = new Person();
          person.setName("张三");
          String name = person.getName();
          System.out.println(name);
          //person.show();
          System.out.println(person);
      }
  }
  class Person{
      private String name;//实例成员变量
      private int age;

      public void setName(String name){
          //name = name;//不能这样写
          this.name = name;//this引用，表示调用该方法的对象
      }
      public String getName(){
          return name;
      }
      //public void show(){
          //System.out.println("name: "+name+" age: "+age);
      //}
      @Override
      public String toString() {
          return "Person{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  '}';
      }
  }

toString 方法会在 println 的时候被自动调用 ，将对象转成字符串这样的操作我们称为 序列化 . toString 是 Object 类提供的方法 , 我们自己创建的 Person 类默认继承自 Object 类 , 可以重写 toString 方法实现我们自己版本的转换字符串方法。 快速生成toString的方法： 在类中点击鼠标右键，按下图操作：

 

构造方法

构造方法是一种特殊方法 , 使用关键字 new 实例化新对象时会被自动调用 , 用于完成初始化操作。

new 执行过程

• 为对象分配内存空间
• 调用对象的构造方法

语法规则

1.方法名称必须与类名称相同

2.构造方法没有返回值类型声明

3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

举个例子：

public class TestModer {
  public static void main(String[] args) {
          Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
          p1.show();
          Person p2 = new Person("张三",80,"男");//调用带有3个参数的构造函数
          p2.show();
  }
}
class Person {
  private String name;//实例成员变量
  private int age;
  private String sex;
  //默认构造函数 构造对象
  public Person() {
      this.name = "王五";
      this.age = 10;
      this.sex = "男";
  }
  public Person(String name, int age, String sex) {
      this.name = name;
      this.age = age;
      this.sex = sex;
  }
  public void show(){
      System.out.println("name: "+name+" age: "+age+" sex: "+sex);
  }
}

注意事项 ：

如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数 。

若类中定义了构造方法，则默认的无参构造将不再生成。

构造方法支持重载， 规则和普通方法的重载一致。

 

this关键字

this 表示当前对象引用 ( 注意不是当前对象 ). 可以借助 this 来访问对象的字段和方法

this有三种用法：

1、this.date-->调用当前对象的属性。

2、this.func()-->调用当前对象的方法。

3、this（）-->调用当前对象的其他构造方法。

前面两种方法我们之前都用过了，接下来我们来看看第三种用法。

class Person { 
private String name;//实例成员变量
private int age; 
private String sex; 
//默认构造方法 构造对象
public Person() { 
//this调用构造函数
this("bit", 12, "man");//必须放在第一行进行显示
} 
//这两个构造方法之间的关系为重载。
public Person(String name,int age,String sex) { 
this.name = name; 
this.age = age; 
this.sex = sex; 
} 
public void show() { 
System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
} 
} 
public class Main{ 
public static void main(String[] args) { 
Person person = new Person();//调用不带参数的构造方法
person.show(); 
}

运行结果：

注意：this（）必须放在第一行！！！否则会报错。

 

代码块

字段的初始化方式有：

1. 就地初始化

2. 使用构造方法初始化

3. 使用代码块初始化

前两种方式前面已经看过了 , 接下来我们介绍第三种方式 , 使用代码块初始化。

代码块可以分为四种：

1、普通代码块（也称本地代码块）

2、构造代码块（也称实例化代码块）

3、静态代码块

4、同步代码块

我们在这里主要认识第二种和第三种。

1、普通代码块

定义在方法中

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

2、构造代码块

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

class Person {
  private String name;
  private int age=19;
  public static int count;
//构造代码块
  {
      this.age = 99;
      System.out.println("构造代码块！");
  }

3、静态代码块

使用 static 定义的代码块。 一般用于初始化静态成员属性。

class Person {
  private String name;
  private int age = 19;
  public static int count;//0
 //静态代码块
  static {
      count = 99;
      System.out.println("静态代码块！");
  }
}

注意：

1、静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。

2、静态代码块执行完毕后 , 实例代码块（构造块）执行，再然后是构造函数执行。

 

匿名对象

1、匿名只是表示没有名字的对象 .

2、没有引用的对象称为匿名对象 .

3、匿名对象只能在创建对象时使用 .

4、如果一个对象只是用一次 , 后面不需要用了 , 可以考虑使用匿名对象。

来看个例子：

class Person { 
private String name; 
private int age; 
public Person(String name,int age) { 
this.age = age; 
this.name = name; 
} 
public void show() { 
System.out.println("name:"+name+" " + "age:"+age); 
} 
} 
public class Main { 
public static void main(String[] args) { 
new Person("caocao",19).show();//通过匿名对象调用方法
//Person person=new Person();//非匿名对象
} 
}

 

小结

以上就是类和对象的使用，一个类可以产生无数的对象，类就是模板，对象就是具体的实例。 类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。 静态代码块优先实例代码块执行，实例代码块优先构造函数执行。 this关键字代表的是当前对象的引用。并不是当前对象。如果有什么不正确的地方大家尽管说哦！

到此这篇关于Java全面细致讲解类与对象的文章就介绍到这了,更多相关Java类与对象内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/m0_65673419/article/details/124361885