Java学习总结-类和对象【JavaSE】


前言

在这里对最近学习的JavaSE中的类和对象的知识总结回忆一下。


一、类

1、类定义的注意事项

(1)一般一个文件当中只定义一个类。
(2) main方法所在的类一般要使用public修饰(注意:Eclipse默认会在public修饰的类中找main方法)。
(3) public修饰的类必须要和文件名相同。
(4) 不要轻易去修改public修饰的类的名称,如果要修改,通过开发工具修改。

2、类的实例化

在java中采用new关键字,配合类名来实例化对象。

(1)new 关键字用于创建一个对象的实例。
(2)使用 . 来访问对象中的属性和方法。
(3)同一个类可以创建多个实例。

代码如下(示例):

public class Main {
    public static void main(String[] args) {
        PetDog dogh = new PetDog(); //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
    }
}

3、类和对象的说明

(1)类只是一个模型一样的东西,用来对一个实体进行描述,限定了类有哪些成员。
(2)类是一种自定义的类型,可以用来定义变量。
(3)一个类可以实例化出多个对象,实例化出的对象占用实际的物理空间,存储类成员变量。
(4)做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子,类就像是设计图,只设计出需要什么东西,但是并没有实体的建筑存在,同样类也只是一个设计,实例化出的对象才能实际存储数据,占用物理空间。

二、this对象

1、为什么要有this对象

代码如下(示例):

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate() {
        System.out.println(year + "/" + month + "/" + day);
    }

    public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
// 对d1,d2,d3的日期设置
        d1.setDay(2020, 9, 15);
        d2.setDay(2020, 9, 16);
        d3.setDay(2020, 9, 17);
// 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

以上代码中setDay函数中的形参名与数据成员名相同,需要this来帮忙分清楚。创建的d1,d2,d3对象都调用setDay函数设置数据以及printDate函数来打印,这些也需要this来分清楚对象。

2、什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象),在成员方法中所有成员变量的操作,都是通过该引用去访问。

代码如下(示例):

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate() {
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }
}

注意:this引用的是调用成员方法的对象。

3、this引用的特性

(1)this的类型:对应类类型引用,即哪个对象调用就是哪个对象的引用类型。
(2) this只能在"成员方法"中使用。
(3)在"成员方法"中,this只能引用当前对象,不能再引用其他对象。
(4)this是“成员方法”第一个隐藏的参数,编译器会自动传递,在成员方法执行时,编译器会负责将调用成员方法的对象的引用传递给该成员方法,this负责来接收。

三、对象的构造及初始化

1、构造方法

(1)构造方法(也称为构造器)是一个特殊的成员方法,名字必须与类名相同,在创建对象时,由编译器自动调用,并且在整个对象的生命周期内只调用一次。

注意:构造方法的作用就是对对象中的成员进行初始化,并不负责给对象开辟空间。

(2)特性:
    名字必须与类名相同。
    没有返回值类型,设置为void也不行。
    创建对象时由编译器自动调用,并且在对象的生命周期内只调用一次(相当于人的出生,每个人只能出生一次)。
    构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)。
    如果用户没有显式定义,编译器会生成一份默认的构造方法,生成的默认构造方法一定是无参的。(注意:如果用户自定义了构造函数则不会提供默认构造函数)
   构造方法中,可以通过this()调用其他构造方法来简化代码。(注意:this()必须放第一行,并且不能形成环)
   绝大多数情况下使用public来修饰,特殊场景下会被private修饰。(涉及单例模式时会遇到)

2、默认初始化

Date d = new Date(2021,6,9);

在程序层面只是简单的一条语句,在JVM层面需要做好多事情,下面简单介绍下:
   检测对象对应的类是否加载了,如果没有加载则加载。
   为对象分配内存空间。
   处理并发安全问题。比如:多个线程同时申请对象,JVM要保证给对象分配的空间不冲突。
   初始化所分配的空间,即:对象空间被申请好之后,对象中包含的成员已经设置好了初始值。
   设置对象头信息。
   调用构造方法,给对象中各个成员赋值。

数据成员按类型设置初始值,引用类型设为null:
在这里插入图片描述

3、就地初始化

在声明成员变量时,就直接给出了初始值。
代码如下(示例):

public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;

    public Date() {
    }

    public Date(int year, int month, int day) {
    }

    public static void main(String[] args) {
        Date d1 = new Date(2021, 6, 9);
        Date d2 = new Date();
    }
}

注意:代码编译完成后,编译器会将所有给成员初始化的这些语句添加到各个构造函数中。

四、封装

1、封装的概念

封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。

2、包

在面向对象体系中,提出了一个软件包的概念,即:为了更好的管理类,把多个类收集在一起成为一组,称为软件包。有点类似于目录。比如:为了更好的管理电脑中的歌曲,一种好的方式就是将相同属性的歌曲放在相同文件下,也可以对某个文件夹下的音乐进行更详细的分类。

Java 中已经提供了很多现成的类供我们使用。 例如Date类:可以使用 java.util.Date 导入 java.util 这个包中的 Date类。
可以使用 import语句导入包。

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        Date date = new Date();
// 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

如果出现冲突的情况,需要显示指定要导入的类名。

import java.util.*;
import java.sql.*;

public class Test {
    public static void main(String[] args) {
    //util和sql中都存在一个Date这样的类 此时就会出现歧义 需要显式指定。
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
    }
}

还可以使用import static导入包中静态的方法和字段。

import static java.lang.Math.*;

public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
	// 静态导入的方式写起来更方便一些.
	// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        double result = sqrt(pow(x, 2) + pow(y, 2));
        System.out.println(result);
    }
}

常见的包:

(1)java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
(2)java.lang.reflect:java 反射编程包。
(3)java.net:进行网络编程开发包。
(4)java.sql:进行数据库开发的支持包。
(5)java.util:是java提供的工具程序包。
(6)java.io:I/O编程开发包。

3、访问限定符

Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用。
在这里插入图片描述
default权限指什么都不写时的默认权限。

五、static成员

在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对象,是所有对象所共享的。

1、static修饰成员变量

特性:
(1)不属于某个具体的对象,是类的属性,所有对象共享的,不存储在某个对象的空间中。
(2) 既可以通过对象访问,也可以通过类名访问,但一般更推荐使用类名访问。
(3) 类变量存储在方法区当中。
(4)生命周期伴随类的一生。(即:随类的加载而创建,随类的卸载而销毁)

2、static修饰成员方法

Java中,被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的。静态成员一般是通过静态方法来访问的。
特性:
(1)不属于某个具体的对象,是类方法。
(2)可以通过对象调用,也可以通过类名.静态方法名(…)方式调用,更推荐使用后者。
(3)不能在静态方法中访问任何非静态成员变量。
(4)静态方法中不能调用任何非静态方法,因为非静态方法有this参数,在静态方法中调用时候无法传递this引用。
(5)静态方法无法重写,不能用来实现多态。

3、static成员变量初始化

注意:静态成员变量一般不会放在构造方法中来初始化,构造方法中初始化的是与对象相关的实例属性。

静态成员变量的初始化分为两种:就地初始化和静态代码块初始化。
(1) 就地初始化
 就地初始化指的是在定义时直接给出初始值。

代码如下(示例):

public class Student {
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom = "Bit306";
// ...
}

(2)静态代码块初始化
 代码块总结在后面。

六、代码块

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字,又可分为以下四种:普通代码块、构造块、静态块、同步代码块(与多线程有关)。

1、普通代码块

代码如下(示例):

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);
    }
}
// 执行结果
x1=10
x2=100

这种用法较少见。

2、构造代码块

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

public class Student {
    //实例成员变量
    private String name;
    private String gender;
    private int age;
    private double score;

    public Student() {
        System.out.println("I am Student 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) {
        Student stu = new Student();
        stu.show();
    }
}
    // 运行结果
    I am instance init()!
    I am Student init()!
    name:bit age:12 sex:man

3、静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。
代码如下(示例):

public class Student {
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.gender = "man";
        System.out.println("I am instance init()!");
    }

    // 静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
    }

    public Student() {
        System.out.println("I am Student init()!");
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

注意事项:
(1)静态代码块不管生成多少个对象,其只会执行一次。
(2)静态成员变量是类的属性,因此是在JVM加载类时开辟空间并初始化的。
(3)如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行(合并)。
(4)实例代码块只有在创建对象时才会执行。
(5)执行顺序:静态代码块、实例代码块、调用的对应的构造方法。

  • 5
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
面向对象编程是一种编程范式,它将程序的构建和设计思路以面向对象的方式进行组织和实现。在Java中,面向对象编程是基于Java SE(Standard Edition)的一种编程方式。第07讲主要介绍了面向对象编程中的一些基本概念和关键术语。 在面向对象编程中,我们将程序中的数据和对数据的操作(方法)封装在一起,形成一个对象对象由两部分构成:属性和方法。属性是用来描述对象的特征,而方法则是对象可以执行的操作。对象之间通过消息(方法调用)进行通信和交互。面向对象的核心思想是通过封装、继承和多态实现程序的复用和扩展。 封装是面向对象编程中的一个重要概念,它指的是将类的属性和方法进行封装,使得外部无法直接访问和修改对象的内部状态,只能通过公共的方法来操作属性和执行方法。封装提供了一种将数据和行为组合在一起的方式,可以保护数据的完整性和安全性。 继承是面向对象编程中的另一个重要概念,它指的是通过定义一个新的类来继承现有类的属性和方法。通过继承,子类可以继承父类的属性和方法,并可以在此基础上进行扩展和修改。继承提供了一种代码复用的机制,可以减少重复编码的工作量。 多态是面向对象编程的又一个重要概念,它指的是同一类型的对象在不同的情况下可以有不同的表现形式。多态通过方法的重写和方法的重载实现。方法的重写指的是在子类中重新定义和实现父类的方法,方法的重载指的是在同一个类中可以定义多个同名但参数列表不同的方法。 总结来说,面向对象编程是一种将程序组织和设计思路以对象为中心的编程方式。在JavaSE中,我们可以通过封装、继承和多态来实现面向对象编程的目标。封装可以提高程序的可维护性和可复用性,继承可以减少重复编码的工作量,多态可以灵活地操作对象。掌握这些基本概念和关键术语,可以帮助我们更好地理解和应用面向对象编程的思想。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值