【Java初阶(五)】类和对象
PU-YUHAN 2024-07-03 09:05:01 阅读 66
❣博主主页: 33的博客❣
▶文章专栏分类: Java从入门到精通◀
🚚我的代码仓库: 33的代码仓库🚚
目录
1. 前言2.面向对象的认识3.类的认识4. 类的实例化4.1什么是实例化4.2类和对象的说明
5.this引用6.对象初始化6.1 构造方法
7.static关键字8.代码块8.1 普通代码块8.2构造代码块8.3 静态代码块8.4 代码块执行顺序
9.总结
1. 前言
Java是一门纯面向对象的语言(Object Oriented Program,简称OOP),用面向对象的思想来涉及程序,更符合人们对事物的认知,对于大型程序的设计、扩展以及维护都非常友好,那么何为对象?何为类呢?这篇文章博主将会详细进行讲解。
<code>本章重点:
掌握类的定义方式以及对象的实例化,类的构造方法,类中的成员变量和成员方法的使用,对象的整个初始化过程。
2.面向对象的认识
在面向对象的世界里,一切皆为对象。
面向对象是解决问题的一种思想,主要依靠对象之间的交互完成一件事情。我们可以借助人洗衣服的例子来进行思考。
传统的方式:注重洗衣服的过程,少了一个环节都不行,如下:
现代洗衣服方式,如下:
总共有4个对象:人,衣服,洗衣液,洗衣机
整个过程:人,衣服,洗衣液,洗衣机之间交互完成,只需要将衣服放进洗衣机,倒入洗衣粉,启动开关即可,不需要关心洗衣机如何洗的衣服。
3.类的认识
类是用来对一个实体(对象)来进行描述的。主要描述对象的属性,哪些功能是干啥的。
类的定义格式如下:
<code>class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}
属性:是用来描述类的,称之为类的成员属性或者类成员变量。
方法:主要说明类具有哪些功能,称为类的成员方法。
以洗衣机为例:
class WashMachine{
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public double length; // 长
public double width; // 宽
public double height; // 高
public String color; // 颜色
public void washClothes(){ // 洗衣服
int a;//局部变量,进入方法时创建,出方法时销毁
System.out.println("洗衣功能");
}
public void dryClothes(){ // 脱水
System.out.println("脱水功能");
}
public void setTime(){ // 定时
System.out.println("定时功能");
}
}
4. 类的实例化
4.1什么是实例化
定义了一个类,就相当于在计算机中定义了一种新的类型。与int,double类似,只不过int和double是java语言自带的内置类型,而类是用户自定义了一个新的类型,比如上述的:WashMachine它是类(一种新定义的类型)有了这些自定义的类型之后,就可以使用这些类来定义实例(或者称为对象)。
用类类型创建对象的过程,称为类的实例化,在java中采用new
关键字,配合类名来实例化对象。
//小狗的类
class PetDog {
public String name;//名字
public String color;//颜色
// 狗的属性
public void barks() {
System.out.println(name + ": 旺旺旺~");
}
// 狗的行为
public void wag() {
System.out.println(name + ": 摇尾巴~");
}
}
//实例化
public class Main{
public static void main(String[] args) {
PetDog dog = new PetDog(); //通过new实例化对象
dogh.name = "阿黄";
dogh.color = "黑黄";
dogh.barks();
dogh.wag();
}
}
输出结果:
阿黄:旺旺旺~
阿黄:摇尾巴~
4.2类和对象的说明
类只是一个模型一样的东西,用来对一个实体进行描述,限定了类有哪些成员.类是一种自定义的类型,可以用来定义变量.一个类可以实例化出多个对象,实例化出的对象 占用实际的物理空间,存储类成员变量
5.this引用
先看一个日期的例子:
//日期类
<code>public class Date {
public int year;
public int month;
public int day;
public void setDay(int y, int m, int d){
year = y;
month = m;
day = d;
}
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();
}
}
问题1
:
我传了3个日期到setDay里面,那么seDay如何知道设置哪一个对象呢?printDate又是如何知道要打印哪一个呢?
其实,this是“成员方法”第一个隐藏的参数,编译器会自动传递,在成员方法执行时,编译器会负责将调用成员方法对象的引用传递给该成员方法,this负责来接收。例如
ublic void setDay(Date this,int y, int m, int d){
year = y;
month = m;
day = d;
}
public void printDate(Date this){
System.out.println(year + "/" + month + "/" + day);
}
<code>问题2.
如果 形参名与成员变量名相同,那函数体中到底是谁给谁赋值?成员变量给成员变量?参数给参数?参数给成员变量?成员变量参数?
public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}
实际上是局部变量赋给自己,并没赋值给成员变量,最后的输出结果就为0。如果要把形参的值赋给成员变量,该如何修改呢?这个时候就可以用this引用:this引用的是调用成员方法的对象。
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
this引用的特性:
>1. this的类型:对应类类型引用,即哪个对象调用就是哪个对象的引用类型
this只能在"成员方法"中使用在"成员方法"中,this只能引用当前对象,不能再引用其他对象
6.对象初始化
通过前面知识点的学习知道,在Java方法内部定义一个局部变量时,必须要初始化,否则会编译失败,但是在定义成员变量中,我们并没有初始化也没报错,为什么呢?那是因为对于一个成员变量来说,在没有初始化之前都有一个默认值,引用类型默认是null,其余简单类型默认为0,boolean类型是false。
6.1 构造方法
构造方法是一个特殊的成员方法,名字必须与类名相同,在创建对象时,由编译器自动调用,并且在整个对象的生命周期内只调用一次。
构造方法特点:
1.名字与类名相同,没有返回值类型,设置为void也不行。
2.一般情况下使用public修饰。
3. 在创建对象时由编译器自动调用,并且在对象的生命周期内只调用一次。
4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)。
5. 当我们没有写任何构造方法时,会默认存在一个无参构造方法,只要存在任何一种构造方法,编译器都不会再提供。
例
:为日期类实例化一个对象
Date date=new Date ();//实际上,没有写构造默认默认调用了无参构造方法
public Date ((int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}//带有参数的构造方法
Date date=new Date (2024,3,3);//调用有参的构造方法
可以通过this来调用其他构造方法
public Date (){
this(2024,3,3)//必须写在第一条语句中!!
}
public Date ((int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
7.static关键字
在学生类实例化三个对象s1、s2、s3,每个对象都有自己特有的名字、性别,年龄,学分绩点,班级等成员信息,这些信息就是对不同学生来进行描述的,如下所示:
class Student {
public String name;
public String sex;
public int age;
public double score;
public String classRoom;
public Student(String name, String sex, int age, double score,String classRoom) {
this.name = name;
this.sex = sex;
this.age = age;
this.score = score;
this.classRoom=classRoom;
}
}
class Main{
public static void main(String[] args) {
Student s1 = new Student("Li leilei", "男", 18, 3.8,"112");
Student s2 = new Student("Han MeiMei", "女", 19, 4.0,"112");
Student s3 = new Student("Jim", "男", 18, 2.6,"112");
}
}
此时,3名同学都在一个班,只要有一份就行了,不需要在每个对象中都去表示那么该如何修改呢?其实只需要把classRoom变成以static修饰,那么这时这个成员变量就不属于这个对象了。
<code>public String classRoom;
这时候如果我们要调用classRoom这个变量,就不再需要new一个对象了,只需要用类名来进行访问。
System.out.println(Student.classRoom);//合理
System.out.println(Student.classRoom);//不合理
如果一个方法被static修饰,那么这个方法也不依赖任何对象。
8.代码块
使用{}定义的一段代码称为代码块。根据代码块定义的位置以及关键字,又可分为以下四种:
普通代码块构造块静态块同步代码块
8.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);
}
}
8.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 = "33";
this.age = 12;
this.sex = "girl";
}
8.3 静态代码块
使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
this.name = "33";
this.age = 12;
this.sex = "girl";
}
// 静态代码块
static {
classRoom = "111";
System.out.println("I am static init()!");
}
注意
静态代码块不管生成多少个对象,其只会执行一次静态成员变量是类的属性,因此是在JVM加载类时开辟空间并初始化的如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行(合并)实例代码块只有在创建对象时才会执行
8.4 代码块执行顺序
如果几种代码块同时出现在一个类中,执行顺序是怎样的呢?
public class Student {
private String name;
private String sex;
private int age;
private static String classRoom;
//实例代码块
{
this.sex = "girl";
System.out.println("我是实例代码块");
}
// 静态代码块
static {
classRoom = "111";
System.out.println("我是静态代码块");
}
public Student(String name, int age) {
this.name = name;
this.age = age;
System.out.println("我是构造方法");
}
}
public class Main {
public static void main(String[] args) {
Student student1=new Student("zhangsan",12);
System.out.println("============");
Student student2=new Student("lisi",14);
}
}
输出结果:
静态代码块最先执行,且执行一次,然后是实例代码块,最后是构造方法。
9.总结
本篇文章主要讲了对象和类的概率,类的定义方式以及对象的实例化,类的构造方法,类中的成员变量和成员方法的使用,对象的整个初始化过程,static关键字应用,代码块的讲解和各种代码块执行顺序,在接下来的文章中我会进一步深入。
<code>下期预告:封装 继承 多态
声明
本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。