Java 类和对象 | 易学教程

1.类和对象初步认识

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

在这里插入图片描述

2.类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。一个类可以产生无数个对象

基本语法

// 创建类
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("睡觉!");
	}
}

类的实例化

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

1.类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。
2.一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。

public class Test3 {

    public static void main(String[] args) {
        Person person = new Person();//通过new实例化对象
        person.eat();//成员方法调用需要通过对象的引用调用
        person.sleep();
        
        //产生对象 实例化对象
        Person person2 = new Person();
        Person person3 = new Person();
    }
}


class Person {
    public int age;//成员属性 实例变量
    public String name;
    public String sex;

    public void eat() {//成员方法
        System.out.println("吃饭!");
    }
    public void sleep() {
        System.out.println("睡觉!"); 
    }
}

3.类的成员

类的成员可以包含以下:字段、方法、代码块、内部类和接口等。

3.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);
    }
}

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

3.3 static 关键字

用 static 修饰的属性或者方法等，都是与类相关，而跟对象无关。

用法：

1、修饰属性
2、修饰方法
3、代码块
4、修饰类

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

public class Test3 {

    public static void main(String[] args) {
        Demo demo1 = new Demo();
        Demo.b++;
        demo1.a++;
        System.out.println("demo1.a = " + demo1.a);
        System.out.println("Demo.b = " + Demo.b);
        System.out.println("----------------");
        Demo demo2 = new Demo();
        Demo.b++;
        demo2.a++;
        System.out.println("demo2.a = " + demo2.a);
        System.out.println("Demo.b = " + Demo.b);
    }
}


class Demo {
    public int a = 1;
    public static int b = 1;

}

结果如下：

demo1.a = 2
Demo.b = 2
----------------
demo2.a = 2
Demo.b = 3

示例代码内存解析:count被static所修饰，所有类共享。且不属于对象，访问方式为:类名 . 属性。

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

静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法只能访问静态数据成员，并可以更改静态数据成员的值。

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

注意事项

静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用, super是当前实例父类实例的引用, 也是和当前实例相关).

4.构造方法

基本语法

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

语法规则：

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

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

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

注意事项

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

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

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

class Person {
    private String name;//实例成员变量 
    private int age;
    private String sex;
    //默认构造函数 构造对象
    public Person() { this.name = "caocao"; this.age = 10; this.sex = "男";
    }
    //带有3个参数的构造函数
    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 p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数 
        p1.show();
        Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数
        p2.show();
    }
}

5.代码块

字段的初始化方式有:

就地初始化

使用构造方法初始化 3. 使用代码块初始化

5.1什么是代码块

使用 { } 定义的一段代码.
根据代码块定义的位置以及关键字，又可分为以下四种:

普通代码块
构造块
静态块
同步代码块

5.2普通代码块

普通代码块:定义在方法中的代码块.

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

这种用法较少见

5.3构造代码块

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

class Person{
private String name;//实例成员变量 private int age;
private String sex;
    public Person() {
        System.out.println("I am Person init()!");
}
	//实例代码块 
	{
 		this.name = "bit";
        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) {
        Person p1 = new Person();
		p1.show(); 
	}
}

注意事项：
实例代码块优先于构造函数执行。

5.4静态代码块

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

class Person{
	private String name;//实例成员变量
	private int age;
	private String sex;
	private static int count = 0;//静态成员变量
	由类共享数据 方法区
	public Person(){
	    System.out.println("I am Person init()!");
	}
	//实例代码块 {
	    this.name = "bit";
	    this.age = 12;
	    this.sex = "man";
	    System.out.println("I am instance init()!");
	}
	//静态代码块 
	static {
		count = 10;//只能访问静态数据成员
        System.out.println("I am static init()!");
    }
     public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
	} 
}
public class Main {
    public static void main(String[] args) {
	} 
}

注意事项：

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块(构造块)执行，再然后是构造函数执行。

6.匿名对象

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

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

代码示例：

 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();//通过匿名对象调用方法
	}
}

总结：

一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
类中定义的属性，大概分为几类:类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
静态代码块优先实例代码块执行，实例代码块优先构造函数执行。注意静态代码块和静态属性的执行顺序是按照书写的先后书序执行的。

来源：CSDN

作者：&从小白到大白&

链接：https://blog.csdn.net/qq_44773719/article/details/103968250

标签

类和对象

实例化