不说废话，直接干货之java中“类和对象的爱恨情仇”

目录

一：初识类和对象

1：类和对象基本定义

2：类和对象的实例化

二：类的成员

1：字段/属性/成员变量

2：方法

3：关于static关键字

a）修饰属性

b）修饰方法

d）应用

总结：

---

一：初识类和对象

1：类和对象基本定义

简单来说，类就是一类对象的统称。而对象就是这一类具体化的一个实例。正常我们在java中是面向对象来编程的，这就将复杂的事情变简单了，只要面对一个对象就行。

2：类和对象的实例化

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

看以下简单的声明一个类

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

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

类中的元素称为：成员属性。类中的函数称为：成员方法。

如：

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 int age;//成员属性 实例变量
    public String name;
    public String sex;
 public void eat() {//成员方法
       System.out.println("吃饭!");  
   }
    public void sleep() {
       System.out.println("睡觉!");  
   }
}
public class Main{
 public static void main(String[] args) {
        Person person = new Person();//通过new实例化对象
        person.eat();//成员方法调用需要通过对象的引用调用
        person.sleep();
        //产生对象     实例化对象
        Person person2 = new Person();
        Person person3 = new Person();
 }
}
//输出结果为
吃饭!
睡觉!

这里注意：

new 关键字用于创建一个对象的实例 .

使用 . 来访问对象中的属性和方法 .

同一个类可以创建对个实例。

二：类的成员

1：字段/属性/成员变量

在类中 , 但是方法外部定义的变量 . 这样的变量我们称为 " 字段 " 或 " 属性 " 或 " 成员变量 "( 三种称呼都可以 , 一般不会严

格区分 ).

用于描述一个类中包含哪些数据

class Person {
    public String name;   // 字段
    public int age; }
class Test {
    public static void main(String[] args) {
Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);
   }
}
// 执行结果
null
0

注意：

使用 . 访问对象的字段 .

" 访问 " 既包含读 , 也包含写 .

对于一个对象的字段如果没有显式设置初始值 , 那么会被设置一个默认的初值

2：方法

就是我们曾经讲过的方法 .

用于描述一个对象的行为。

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

此处的 show 方法 , 表示 Person 这个对象具有一个 " 展示自我 " 的行为 .

这样的 show 方法是和 person 实例相关联的 . 如果创建了其他实例 , 那么 show 的行为就会发生变化。

Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person2.show()
    
// 执行结果
我叫李四, 今年20岁

3：关于static关键字

a）修饰属性

Java 静态属性和类相关 , 和具体的实例无关 . 换句话说 , 同一个类的不同实例共用同一个静态属性。

class TestDemo{
    public int a;
    public static int count; }
public class Main{
    
 public static void main(String[] args) {
        TestDemo t1 = new TestDemo();
        t1.a++;
        TestDemo.count++;
        System.out.println(t1.a);
        System.out.println(TestDemo.count);
        System.out.println("============");
        TestDemo t2 = new TestDemo();
        t2.a++;
        TestDemo.count++;
        System.out.println(t2.a);
        System.out.println(TestDemo.count);
   }
}

输出结果为：

11
============
12

b）修饰方法

如果在任何方法上应用 static 关键字，此方法称为静态方法。

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

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

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

class TestDemo{
    public int a;
    public static int count;
    
    public static void change() {
        count = 100;
        //a = 10; error 不可以访问非静态数据成员
   }
}
public class Main{
      TestDemo.change()；//无需创建实例对象 就可以调用
        System.out.println(TestDemo.count);   
   }
}

//输出结果为
100

注意事项 1 : 静态方法和实例无关 , 而是和类相关 . 因此这导致了两个情况 :

静态方法不能直接使用非静态数据成员或调用非静态方法 ( 非静态数据成员和方法都是和实例相关的 ).

this 和 super 两个关键字不能在静态上下文中使用 (this 是当前实例的引用 , super 是当前实例父类实例的引用 , 也

是和当前实例相关 ).

d）应用

接下里给出一个例子，希望能对大家有所启发：

class Person {
    public int age;//实例变量   存放在对象内
    public String name;//实例变量
    public String sex;//实例变量
    public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
    public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改
    public static final int  COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更
改
    //实例成员函数
    public void eat() {
       int a = 10;//局部变量
       System.out.println("eat()!");  
   }
    //实例成员函数
    public void sleep() {
       System.out.println("sleep()!");  
   }
    //静态成员函数
     public static void staticTest(){
         //不能访问非静态成员
        //sex = "man"; error
        System.out.println("StaticTest()");
     }
}
public class Main{
 public static void main(String[] args) {
 //产生对象 实例化对象
        Person person = new Person();//person为对象的引用
        System.out.println(person.age);//默认值为0
        System.out.println(person.name);//默认值为null
        //System.out.println(person.count);//会有警告!
        //正确访问方式：
        System.out.println(Person.count);
        System.out.println(Person.COUNT);
        Person.staticTest();
        //总结：所有被static所修饰的方法或者属性，全部不依赖于对象。
        person.eat();
        person.sleep();
 }
}

输出结果如下：

0
null
0
99
StaticTest()
eat()!
sleep()!

总结：

今天主要写了类和类的实例化，另外提一点，正常类里都应该有构造方法，如果没有的话系统也会·给出默认方法。