Java——类和对象超详细总结

类和对象

1.类与对象的初步认识

c语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。

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

注意事项

和之前写的方法不同,此处写的方法不带static关键字,我们我们会详细解释static是干什么的。

类的实例化

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

  1. 类只是一个模型一样的东西,限定了类有哪些成员。
  2. 一个类可以实例化出多个对象,实例化出的对象,占用实际的物理空间,存储类成员变量
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 DemoTest {
    public static void main(String[] args) {
        Person person = new Person();    //  通过new实例化对象
        Person.eat();    //  成员方法调用需要通过对象的引用调用
        Person.sleep();
        //  产生对象  实例化对象
        Person person2 = new Person();
        Person person3 = new Person();
    }
}

输出结果为:

吃饭!
睡觉!

注意事项

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

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

  3. 同一个类可以创建多个实例。

3.类的成员

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

此处我们重点介绍前三个。

3.1字段/属性/成员变量

在类中,但是方法外部定义的变量。这样的变量我们称为"字段"或"属性"或"成员变量"(三种称呼都可以,一般不会严格区分),用于描述一个类中包含哪些数据。

class Person{
    public String name;    //  字段
    public int age;
}

public class TestDemo {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

//执行结果
null
0

注意事项

  1. 使用.访问对象的字段。
  2. "访问"既包含读,也包含写。
  3. 对于一个对象的字段如果没有显式设置初始值,那么会被设置一个默认的初值。

默认值规则

对于各种数字类型,默认值为0。

对于boolean类型,默认值为false

对于引用类型(String,Array,以及自定制类),默认值为null.

Person person = null;
//这个引用不指向任何的对象

Person person = new Person();
Person person2=person;
//person2这个引用指向person这个引用所指向的对象

Person person = new Person();
person = new Person();
person = new Person();
person = new Person();
//一个引用不可以同时指向多个对象 实际指向的是最后一个对象

字段就地初始化

很多时候我们不希望字段使用默认值,而是需要我们显式设定初值,可以这样写:

class Person{
    public String name = "ljj";    
    public int age = 18;
}

public class TestDemo {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

//执行结果
ljj
18
3.2方法

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

class Person{
    public String name = "ljj";    
    public int age = 18;
    
    public void show(){
       System.out.println("我叫"+name+",今年"+age+"岁")}
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

//执行结果
我叫ljj,今年18

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

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

Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person.show();

//执行结果
我叫李四,今年20
3.3 static关键字
  1. 修饰属性
  2. 修饰方法
  3. 代码块
  4. 修饰类

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

class TestDemo1{
    public int a;
    public static int count;
}

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

输出结果为:

1
1
===============
1
2

b)修饰方法

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

  1. 静态方法属于类,而不属于类的对象。
  2. 可以直接调用静态方法,而无需创建类的实例。
  3. 静态方法可以访问静态数据成员,并可以更改静态数据成员的值。
class TestDemo1{
    public int a;
    public static int count;
    
    public static void change(){
        count = 100;
        //a = 10;  error  不可以访问非静态数据成员
    }
}

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

输出结果:

100

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

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

注意事项2

  1. 我们曾经写的方法为了简单,都统一加上了static。但实际上一个方法具体要不要带static,都需要视情形而定。
  2. main方法为static方法。

4.封装

软件开发的本质就是对程序复杂程度的管理,如果一个软件代码复杂程度太高,那么就无法继续维护。如何管理复杂程度?封装就是最基本的方法。

在我们写代码的时候经常会涉及两种角色:类的实现者类的调用者

封装的本质就是让类的调用者不必了解类的实现者是如何实现类的,只要知道如何使用就行了。

这样就降低了类使用者的学习和使用成本,从而降低了复杂程度。

4.1 private实现封装

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

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

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

直接使用public

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

这样的代码导致类的使用者(main方法的代码)必须要了解Person类内部的实现,才能够使用这个类,学习成本较高。

一旦类的实现者修改了代码(例如把name改成myName),那么类的使用者就需要大规模的修改自己的代码,维护成本较高。

范例:使用private封装属性,并提供public方法供类的调用者使用。

class Person{
    private String name = "ljj";    
    private int age = 18;
    
    public void show(){
        System.out.println("我叫"+person.name+",今年"+person.age+"岁");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

//执行结果
我叫ljj,今年18

此时字段已经使用private来修饰,类的调用者(main方法中)不能直接使用。而需要借助show方法。此时类的使用者就不必了解Person类的实现细节。

同时如果类的实现者修改了字段的名字,类的调用者不需要做出任何修改(类的调用者根本访问不到name,age这样的字段)。

注意事项

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

当我们使用private来修饰字段的时候,就无法直接使用这个字段了。

代码示例

class Person{
    private String name = "ljj";    
    private int age = 18;
    
    public void show(){
        System.out.println("我叫"+person.name+",今年"+person.age+"岁");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.age=20
        person.show();
    }
}

//编译出错
java: age可以在Person中访问private

此时如果需要获取或者修改这个private属性,就需要使用getter/setter方法。

代码示例

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);
    }
}
    
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("ljj");
       String name = person.getName();
        System.out.println(name);
        person.show();
    }
}

//运行结果
ljj
name:ljj age:0

注意事项

getName即为getter方法,表示获取这个成员的值。

setName即为setter方法,表示设置这个成员的值。

当set方法的形参名字和类中的成员属性名字一样的时候,如果不使用this,相当于赋值,this表示当前实例的引用。

不是所有的字段都一定要提供setter/getter方法,而是要根据实际情况决定提供哪种方法。

在IDEA中可以使用alt+insert(或者alt+F12)快速生成setter/getter方法。在VSCode中可以使用鼠标右键菜单->源代码操作中自动生成setter/getter方法。

5.构造方法

5.1基本语法

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

new执行过程

  1. 为对象分配内存空间

  2. 调用对象的构造方法

语法规则

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

注意事项

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

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

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

代码示例

class Person{
    private String name;    //  实例成员变量    
    private int age;
    private String sex;
    //  默认构造函数  构造对象
    public Person(){
        this.name = "ljj";
        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 TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();    //调用不带参数的构造函数  如果程序没有提供会调用不带参数的构造函数
        p1.show();
        Person person2 = new Person("李四",80,"男”);    //调用不带参数的构造函数  
        p2.show();
    }
}

//执行结果
name:ljj age:10 sex:男
name:李四 age:80 sex:
5.2 this关键字

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

class Person{
    private String name;    //  实例成员变量    
    private int age;
   //  默认构造函数  构造对象
    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 TestDemo {
    public static void main(String[] args) {
        Person person = new Person();    //  调用不带参数的构造函数
        person.show();
    }
}

//执行结果
name:bit age:12 sex:man

6.认识代码块

字段的初始化方式有:

  1. 就地初始化
  2. 使用构造方法初始化
  3. 使用代码块初始化

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

6.1什么是代码块

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

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

  1. 普通代码块
  2. 构造块
  3. 静态块
  4. 同步代码块
6.2普通代码块

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

public class TestDemo {
    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
6.3构造代码块

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

class Person{
    private String name;    //  实例成员变量    
    private int age;
    private String sex;
    
    public Person(){
        System.out.println("I am Person init()!");
    }
    
    //实例代码块
    {
        this.name = "ljj";
        this.age = 18;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    
     public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();   
        p1.show();
    }
}

//运行结果
I am instance init()!
I am Person init()!
name:ljj age:18 sex:man

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

6.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 = "ljj";
        this.age = 18;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    
    //静态代码块
    static{
        count = 10;    //  只能访问静态数据成员
        System.out.println("I am instance init()!");
    }
    
    public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();   
        Person p2 = new Person();    //  静态代码块是否还会被执行?
    }
}

注意事项

  1. 静态代码块不管生成多少个对象,都只会执行一次,且是最先执行的。
  2. 静态代码块执行完毕后,实例代码块(构造块)执行,再然后是构造函数执行。
  • 35
    点赞
  • 85
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 22
    评论
评论 22
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

地火轰雷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值