从零开始的 Java 学习类和对象的认识

Posted 2021-11-24 w_xhjk

类和对象

• 1、对类和对象的初步认识
• 2、类和类的实例化
• 3、类的成员
• • 普通成员变量和方法
  • 静态成员变量和方法
• 4、封装
• 5、构造方法
• • 基本语法
  • this关键字
• 6、代码块
• 7、匿名对象

1、对类和对象的初步认识

什么是类？什么是对象？
简单的来说：
类：相当于一个模板，用来描述和包含一类对象的行为和属性。一个类，可以产生无数的对象。
对象：就是类的一个实例是由模板产生的样本，有行为和属性。比如说一个人是一个对象，他的行为有吃饭、睡觉，打豆豆，而他的属性有姓名、年龄，性别。

JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
在我们开发时我们要：找对象，建对象，用对象，并维护对象之间的关系，这也是我们学习的重点。
简而言之
面向对象就是用代码(类)来描述客观世界的事物的一种方式. 一个类主要包含一个事物的属性和行为。

2、类和类的实例化

声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。
基本语法

// 创建类
class <class_name>{
    field;//成员属性
    method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();

class，用来定义一个类，class_name表示类的名字，类名的书写格式为大驼峰，在类里面包含了字段（属性，成员变量），也包含了方法（行为）。
示例

class Person {
   public int age;//成员属性 实例变量
   public String name;
   public String sex;
   public void eat() {//成员方法
      System.out.println("吃饭!");
   }
   public void sleep() {
      System.out.println("睡觉!");
   }
}

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

class Person{
    public String name;//成员变量
    public int age;
    public String sex;
    public void eat(){//成员方法
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
public class text {
    public static void main(String[] args) {
         Person person=new Person();//通过new实例化对象
         person.eat();//通过对象的引用来访问普通的成员变量
         person.sleep();
         //产生对象 实例化对象
         Person person1=new Person();
         Person person2=new Person();
    }
}

输出结果为

吃饭
睡觉

3、类的成员

普通成员变量和方法

类中的成员包括成员变量（字段，属性）和成员方法（行为）。

class Person{
    public String name;//成员变量
    public int age;
    public String sex;
    public void eat(){//成员方法
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

注意：如果未赋初值，打印的结果就是变量类型的默认值，例如：

class Person{
    public String name;//
    public int age;
    public String sex;
}
public class text {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);  //结果为null
        System.out.println(person.age);   //结果为0
    }

静态成员变量和方法

普通成员变量通过static关键字的修饰变为静态成员变量。
成员变量被static所修饰，存放在方法区中，所有类共享。且不属于对象。
访问方式为：类名.属性
示例：

class TextDemo{
    public int a;
    public static int count;
}
public class text {
    public static void main(String[] args) {
      TextDemo t1=new TextDemo();
      t1.a++;
      TextDemo.count++;                    //结果
      System.out.println(t1.a);            // 1
      System.out.println(TextDemo.count);  // 1

      TextDemo t2=new TextDemo();
      t2.a++;
      TextDemo.count++;
      System.out.println(t1.a);            // 1
      System.out.println(TextDemo.count);  // 2
    }
}

同理，方法也可以被static修饰

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

在定义时注意以下几点：

1. 普通的方法里不能定义静态的成员变量
2. 普通的方法里可以定义静态的方法
3. 静态的方法里不能定义普通的成员变量
4. 静态的方法中不能定义普通的方法

因为static定义的变量是类变量，是属于类的。
方法的调用需要对应的引用，而static的定义可以使类不需要引用直接调用，这就出现了冲突。
拓展：

1.null在java中表示“空引用”，表示不引用任何对象，相当于C语言中的空指针。

Person person=null;

2.表示person2这个引用指向 person1 这个引用所指向的对象，相当于指向同一个对象。

Person person1=new Person();
Person person2=person1;

3.一个引用不可以指向多个对象。

4.引用不一定在栈上，如图示：

class Person{
    public int age;
    public String name;
}
class Text {
    Person person =new Person();
    public static void main(String[] args) {
      Text text=new Text();
    }
}

4、封装

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

• 被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用。
• 被 private 修饰的成员变量或者成员方法,不能被类的调用者使用。

当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了。
此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法

class Person{
    private String name;
    private int age;
    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;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\\'' +
                ", age=" + age +
                '}';
    }
}
public class text {
    public static void main(String[] args) {
        Person person =new Person();
        person.setAge(12);
        person.setName("345");
        person.getAge();
        person.getName();
        System.out.println(person);
    }
}

结果为Person{name='345', age=12}

this.代表当前对象的引用。

5、构造方法

基本语法

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

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

语法规则：

1. 方法名与类名相同
2. 构造方法没有返回值类型声明
3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

注意事项：

1. 如果没有实现任何的构造方法，编译器会帮我们默认生成一个不带参数的构造方法，也就是说一个类至少会有一个构造方法，即使我们没有写。
2. 如果当前类有其他的构造方法，那么编译器就不会帮我们生成不带参数的构造方法。
3. 构造方法之间可以构成重载。

class Person{
    public String name;
    public int age;
    public Person(){   //如果没有写不带参数的构造方法，编译器会默认生成一个，这里是写了
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){   //构造带一个String类型参数的构造方法
        this.name=name;
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){   //构造带一个String类型和一个int类型参数的构造方法
        this.name=name;
        this.age=age;
        System.out.println("带两个参数的构造方法");
    }
}
public class text {
    public static void main(String[] args) {
        Person person =new Person();  //这里其实就是在调用不带参数的构造方法
        Person person1=new Person("123");
        Person person2=new Person("123",456);
    }
}

this关键字

this有三种用法：

 - this.data             调用当前对象的属性
 - this.func()           调用当前对象的方法
 - this()                调用当前对象的其他构造方法

this()调用当前对象的其他构造方法如下所示：

注意：
this()必须放在第一行，并且只能放在构造方法中。

6、代码块

代码块分为本地代码块、实例代码块、静态代码块，同步代码块。
在这里我们学习的重点是实例和静态代码块。

class Person{
    public String name;
    public int age;
    {
        System.out.println("实例代码块"); //实例代码块
    }

    static{
        System.out.println("静态代码块"); //静态代码块
    }
    public Person(){
        System.out.println("Person()不带参数的构造方法");
    }
}
public class text {
    public static void main(String[] args) {
        Person person =new Person();
        Person person1 =new Person();
    }
}

调用的结果是

静态代码块
实例代码块
Person()不带参数的构造方法
实例代码块
Person()不带参数的构造方法

class Person{
    public String name;
    public int age;
    static int count;
    {
        System.out.println("实例代码块"); //这个就是实例代码块
    }

    static{
        System.out.println("静态代码块"); //静态代码块
    }
    public Person(){
        System.out.println("Person()不带参数的构造方法");
    }
}
public class text {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

结果是：

静态代码块
0

根据上述代码，可以发现静态代码块只会被执行一次而且是最先执行的（在类加载的时候就执行），并且静态代码块不用实例化对象也会被执行。

若果都是静态的前提下，静态代码块与静态变量的执行顺序要看代码定义的顺序（当变量未被初识话的情况下例外）。

class Person{
    public String name;
    public int age;
    public static int count=10;
    static{
        count=99;
    }
}
public class text {
    public static void main(String[] args) {
        System.out.println(Person.count);  // 结果为99
    }
}

7、匿名对象

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

• 没有引用的对象称为匿名对象。
• 匿名对象只能在创建对象时使用。
• 如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象。

class Person{
    public String name;
    public int age;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
public class text {
    public static void main(String[] args) {
        new Person().eat();
        new Person().sleep();
        Person person1=new Person();
        person1.eat();
        person1.sleep();
    }
}

根据代码可以看出区别，匿名对象相当于一个一次性的对象。