`
Mini_Xiao
  • 浏览: 7106 次
  • 性别: Icon_minigender_2
最近访客 更多访客>>
文章分类
社区版块
存档分类
最新评论

java---类与对象2(7.8)

阅读更多

第三节 类和对象2

纲要:1.构造方法

      2.方法重载

      3.this关键字

      4.值传递

      5.引用传递

一.构造方法

1.类是由属性和方法组成,

 方法包括:普通方法

           构造方法

           抽象方法

2.构造方法的格式:

     public  类名(数据类型 参数名,......{

           //方法体

     }

  普通方法的格式:

     public  返回值类型 方法名(数据类型 参数名,......{

           //方法体

     }

3.构造方法与普通方法的区别:

 (1)返回值类型不同。

      构造方法返回的是一个地址,因此不需要返回值类型。

      普通方法必须要返回值类型,没有返回值时,也需要写void

 (2)方法名不同。

      构造方法的方法名必须与类名相同。

      普通方法的方法名一般不与类名相同。

 (3)用途不同。

      构造方法用于实例化对象,也可以给对象属性设置初始值。

      普通方法用于实现对象的行为、作用、用途等,可以给对象属性赋值,但不是初始值。

(注:什么是初始值?即对象在生成时就带有的数值。

      例如:我们刚出生时就有体重,那个体重就是我们体重的初始值,我们可以通过

            各种方法让我们体重增加,比如:进食。)

4.进一步说明构造方法的用途:

 用途:I . 实例化对象,

       II . 给对象的属性设置初始值。

 说明:(1)如果类中没有写构造方法,

           java会给该类自动添加一个默认的构造方法。

           该构造方法不带任何参数,方法体中也没有任何内容。

           因此,在该情况下构造方法只能实例化对象而无法给属性设置初始值。

      (2)如果类中写了构造方法,

           默认的构造方法会被覆盖掉,就无法调用默认的构造方法 。

           如果在类中写了带参数的构造方法,

           那么构造方法在实例化对象的同时也可以给属性设置初始值。

   

      (3)每实例化一次,就会在内存中开辟一段内存空间,生成一个对象。

           因此如下语句是两个对象。

        Student  stu;

        stu=new Student();

        stu=new Student(); 

      (4)用构造函数实例化对象是,由于构造函数返回的是内存地址,

           因此在对象名中  存储的是地址,图解如下:



 

5.代码示例:

 

/**
 * 定义一个person类
 * @author zhouxiaoxiao
 *
 */
public class person {

	private String name;   //姓名属性
	private char sex;    //性别属性
	/**
	 * 设置姓名的方法
	 * @param n 姓名参数
	 */
	public void setName(String n){
		name=n;
	}
	/**
	 * 获取姓名的方法
	 * @return 返回姓名
	 */
	public String getName(){
		return name;
	}
	/**
	 * 设置性别的方法
	 * @param s 性别参数
	 */
	public void setSex(char s){
		sex=s;
	}
	/**
	 * 获取性别的方法
	 * @return 返回性别
	 */
	public char getSex(){
		return sex;
	}
}

 

/**
 * 定义一个student类
 * @author zhouxiaoxiao
 *
 */
public class student {
	
	private String name;  //姓名属性
	private int score;  //学分属性
	/**
	 * 带姓名参数的构造函数
	 * @param n 学生姓名参数
	 */
	public student(String n){
		name=n;
	} 
	/**
	 * 设置姓名的方法
	 * @param n 姓名参数
	 */
	public void setName(String n){
		name=n;
	}
	/**
	 * 获取姓名的方法
	 * @return 返回姓名
	 */
	public String getName(){
		return name;
	}
	/**
	 * 设置学分的方法
	 * @param s 学分参数
	 */
	public void setScore(int s){
		score=s;
	}
	/**
	 * 获取学分的方法
	 * @return 返回学分
	 */
	public int getSex(){
		return score;
	}	
}

 

/**
 * 构造方法实例化对象
 * @author zhouxiaoxiao
 *
 */
public class construct {

	/**
	 * 程序主函数入口
	 */
	public static void main(String[] args) {

		//person类中没有定义构造方法,使用默认的构造方法实例化一个person类对象
		person p=new person();
		
		//输出认证对象名p中存储的是一个地址
		System.out.println("person类的对象名p存储的值是:"+p);
		
		//student类中定义了一个带姓名参数的构造函数,默认函数被覆盖了,因此下列语句不成立
		//student s3=new student();
		
		//使用带参数的构造函数实例化一个student类对象,并初始化姓名属性
		student s1=new student("小名");
		System.out.println("学生类对象s1的姓名为:"+s1.getName());
		
		//也可以用一个对象实例化另一个对象。
		student s2=s1;
		System.out.println("学生类对象s2的姓名为:"+s2.getName());
		
	}

}

 

二.方法重载:包括普通方法重载和构造方法重载

1.为什么要用到方法重载?

     在同一个类中,不同的参数设置使用相同的方法时要用到方法重载。

I. 普通方法重载举例:

  我们在记一个东西或知识点时,

     可能我们需要一支笔和一张纸,

          能只要一台电脑,

              也可能什么都不需要,用脑就可以记下来。

                  在这里我们就需要不同类型或个数的参数,

                      但是却是同一个记东西的方法,

                          这时我们就可以用到普通方法重载。

II. 构造方法重载举例:

   我们在买杯子的时候会发现,

      有些杯子不带手柄,有些带手柄,有些既带了手柄又带了盖子,

          这些杯子在生产出来的时候就有不同的特征,

              因此他们在生产的时候肯定用的是不同的方法,

                 也就是说会用到不同的构造方法来实例化,

                     这就会用到构造方法的重载。

 

 

2.实现方法重载的条件:

   I. 方法名必须要完全相同。

   II. 方法所带的参数类型、个数、顺序必须至少一个不同。

   III. 访问限定符、返回值类型、方法体可以相同也可以不同。

3.如何调用重载后的方法

对象会根据参数的类型、个数和顺序,选择相匹配的方法进行调用。

 调用格式与没重载的相同。

4.代码示例:

/**
 * 定义一个person类
 * @author zhouxiaoxiao
 *
 */
public class person {

	private String name;   //姓名属性
	private char sex;    //性别属性
	/**
	 * 定义一个不带参数的构造函数
	 */
	public person(){
	}
	/**
	 * 重载一个带姓名参数的构造函数
	 * @param n 姓名参数
	 */
	public person(String n){
		name=n;
	}
	/**
	 * 设置姓名的方法
	 * @param n 姓名参数
	 */
	public void setName(String n){
		name=n;
	}
	/**
	 * 获取姓名的方法
	 * @return 返回姓名
	 */
	public String getName(){
		return name;
	}
	/**
	 * 设置性别的方法
	 * @param s 性别参数
	 */
	public void setSex(char s){
		sex=s;
	}
	/**
	 * 获取性别的方法
	 * @return 返回性别
	 */
	public char getSex(){
		return sex;
	}
	/**
	 * 定义一个思考的方法
	 */
	public void think(){
		System.out.println(name+"正在思考中!");
	}
	/**
	 * 重载一个带时间参数的思考方法
	 * @param hour 思考的时间
	 */
	public void think(int hour){
		System.out.println(name+"思考了"+hour+"小时!");
	}	
}
/**
 * 方法重载
 * @author zhouxiaoxiao
 *
 */
public class reload {

	/**
	 * 程序主函数入口
	 */
	public static void main(String[] args) {

		//用无参的构造函数实例化一个person类对象
		person p1=new person();
		//调用没有重载的设置名字的方法
		p1.setName("Min");   
		
		//用带一个姓名参数的构造方法实例化一个对象
		person p2=new person("Max");
		
		//待用不带参数的思考方法
		p1.think();
		p2.think();
		
		//调用带int型参数的思考方法
		int h=3;
		p2.think(h);
	}

}

 

三.this关键字

引入this关键字的目的:

1.解决由方法参数与属性同名引起的问题。

/**
 * 定义一个person类
 * @author zhouxiaoxiao
 *
 */
public class person {

	private String name;   //姓名属性
	/**
	 * 设置姓名的方法
	 * @param n 姓名参数
	 */
	public void setName(String name){
		name=name;
	}
	/**
	 * 获取姓名的方法
	 * @return 返回姓名
	 */
	public String getName(){
		return name;
	}
	/**
	 * 程序主函数入口
	 */
    public static void main(String[] args){

    	person p=new person();
    	p.setName("小命");
    	System.out.println("这个人的姓名为:"+p.getName());
    }
}

 

如上代码,

  当方法中的姓名参数与姓名属性相同时,

    在方法体中,给姓名属性赋值时,

      虽然java会在等号左边的name添加默认的关键字this

         但是由于java的就近原则优先于添加默认关键字this这一原则,

            与name属性相比,方法体中的name与方法参数中的name比较近,

               因此根据就近原则,等号左边的name其实也是name参数,

                  方法体中的语句就类似于name参数=name参数的赋值,

                     而并没有给姓名属性赋上值。

  输出结果为:

      这个人的姓名为:null

为了解决上面的问题,下面我们引入关键字。

/**
 * 定义一个person类
 * @author zhouxiaoxiao
 *
 */
public class person {

	private String name;   //姓名属性
	/**
	 * 设置姓名的方法
	 * @param n 姓名参数
	 */
	public void setName(String name){
		this.name=name;  //使用this关键字
	}
	/**
	 * 获取姓名的方法
	 * @return 返回姓名
	 */
	public String getName(){
		return name;
	}
	/**
	 * 程序主函数入口
	 */
    public static void main(String[] args){

    	person p=new person();
    	p.setName("小命");
    	System.out.println("这个人的姓名为:"+p.getName());
    }
}

由于this表示的是当前对象,

   所以等号左边的name参数,明显表示当前对象的name属性,

      name属性即可赋值成功。

 输出结果为:

       这个人的姓名为:小命

2.调用当前类的构造函数,如下代码:

 

	/**
	 * 定义一个带姓名参数的构造函数
	 * @param name 姓名参数
	 */
    public person(String name){
    	this.name=name;
    }
    /**
     * 在无参的构造函数中调用带参数的构造函数
     */
    public person(){
    	this("小明");
    }

 

在构造函数中,通过this关键字可以调用同类中的非本身的构造函数。

(注:如果调用本身就会无限循环下去。)

调用格式:this(参数1......);

四.值传递:

1.传递的内容:值。

2.使用范围:八种基本的数据类型。

          Boolean(布尔型)byte(字节型)short(短整型)int(整型)

          long(长整型)Char(字符型)float(单精度浮点型)double(双精度浮点型) 

3.传递过程:

 已知在student类中有一个学习的方法

 

	/**
	 * 学习方法
	 * @param hour 参数
	 */
	public void study(int hour){
		score=hour++;
		System.out.println(name+"学习了,学分加"+hour);
	}

 

在主函数中定义了一个整型常量int hour=3

并实例化了一个stu对象来调用study方法,

在此过程中的内存改变如下:

 

 

 
 

在该过程中,hour只是把数值3传给了方法中的形参,传的是数值。

在方法体中改变了数值并不会对hour产生任何影响。

 

五.引用传递:

1.传递内容:地址。

2.使用范围:适用于java的引用类型(对象类型)

           包括:类、抽象类、接口、数组等。

3.传递过程:

已知一个student

public class student {
	
	private String name;  //姓名属性
	/**
	 * 不带参数的构造寒素
	 */
	public student(){
	}
	/**
	 * 重载一个带姓名参数的构造函数
	 * @param n 学生姓名参数
	 */
	public student(String n){
		name=n;
	} 
	/**
	 * 设置姓名的方法
	 * @param n 姓名参数
	 */
	public void setName(String n){
		name=n;
	}
	/**
	 * 获取姓名的方法
	 * @return 返回姓名
	 */
	public String getName(){
		return name;
	}
	/**
	 * 程序主函数入口
	 */
	public static void main(String[] args) {

		student s1=new student();
		student s2=new student();
		student s3=new student("小白");
		s2.setName("小黑");
		//没赋值前的姓名
		System.out.println("没赋值之前");
		System.out.println("s1的姓名是:"+s1.getName());
		System.out.println("s2的姓名是:"+s2.getName());
		System.out.println("s3的姓名是:"+s3.getName());
		s2=s1;
		s1=s3;
		s3=s2;
		//赋值后的姓名
		System.out.println("赋值后");
		System.out.println("s1的姓名是:"+s1.getName());
		System.out.println("s2的姓名是:"+s2.getName());
		System.out.println("s3的姓名是:"+s3.getName());		
	}
}

  

在主函数中分别执行如下语句,内存变化如下图:



 

 

 
最后输出结果为:



 
 

  • 大小: 7.6 KB
  • 大小: 8.4 KB
  • 大小: 14.1 KB
  • 大小: 15.2 KB
  • 大小: 59.4 KB
  • 大小: 44.6 KB
  • 大小: 12.3 KB
  • 大小: 5.5 KB
  • 大小: 35.7 KB
分享到:
评论

相关推荐

    21天学通Java-由浅入深

    类与对象(精彩视频:48分钟) 96 6.1 什么是面向对象 96 6.1.1 面向对象编程的特点 96 6.1.2 面向对象编程与面向过程编程的区别 97 6.2 什么是类 97 6.2.1 类的定义和对象的创建 97 6.2.2 如何使用现有类 99 6.2.3 ...

    Java软件开发实战 Java基础与案例开发详解 7-2 对象模型建立 共19页.pdf

    2. **对象识别**:根据需求说明书抽取出特定的属性和行为的对象,并将具有相同属性和行为的对象归为一类。 3. **类的设计**:定义每个类的属性和方法,并考虑类之间的关系。 4. **对象模型建立**:使用UML等工具对类...

    C++大学教程

    1.9 Java、Internet与万维网--------------------------------------------7 1.10 其它高级语言------------------------------------------------------8 1.11 结构化编程-----------------------------------...

    java学习笔记 初学者必读

    2.2. Java中基本概念 2-5 3. 二•定义,关键字和类型 3-5 3.1. 注释的三种形式 3-5 3.2. Java代码中的“;”、“{}”、“ ” 3-5 3.3. 标识符 3-5 3.4. 数据类型 3-6 3.5. 命名规则 3-6 4. 三•表达式和控制流 4-6 ...

    java 实效编程百例

    - Java 语言的主要特点包括平台无关性、面向对象、安全性等。 - **1.4 搭建Java开发环境** - 如何配置 JDK 和 JRE,安装集成开发环境(IDE),如 Eclipse 或 IntelliJ IDEA。 - **1.5 编写第一个 Java 程序** - ...

    java笔记 java笔记

    - **面向对象**:Java是一种纯粹的面向对象的语言,几乎所有的数据都是以对象的形式来表示。 - **平台无关性**:通过Java虚拟机(JVM),使得Java程序能够在多种平台上运行。 - **安全性**:Java具有强大的安全机制,...

    java全集.pdf JAVA全集

    - **静态变量**:与类关联,而不是与对象关联。 - **静态方法**:可以直接通过类名调用,无需创建对象。 - **静态类**:在Java中,类本身不能被声明为静态的。 **7.5 Singleton模式** - 保证一个类只有一个实例,...

    最新UC浏览器_V7.8_java源代码

    1. **Java语言**:UC浏览器的源代码是用Java编写的,这表明它遵循了Java的面向对象编程原则,包括类、对象、封装、继承和多态性等核心概念。开发者可以学习到如何在实际项目中运用这些概念,以及如何设计高效、可...

    Java入门学习笔记

    它的名称与类相同,并且没有返回类型。 **6.8 封装** - 封装是隐藏对象的具体实现细节,只暴露必要的接口给外部使用。 **6.9 方法的重载** - 方法重载允许在一个类中定义多个同名但参数不同的方法。 #### 七、...

    java编程基础,应用与实例

    第2章 理解对象与类 9 2.1 什么是对象 9 2.2 什么是类 9 2.3 HelloJava示例的分析 11 2.4 巩固练习 12 第3章 Java语言的基本语法 13 3.1 代码编写规则 13 3.2 注释 13 3.3 标识符 14 3.4 变量和...

    CoreJava笔记.doc

    - 反射是Java中一种强大的特性,允许运行时获取类的信息并操作类的对象。 - 可以用来实现动态代理、框架开发等。 #### 八、异常 **8.1 异常的基本概念** - 异常是在程序执行过程中发生的异常情况。 - Java中的...

    JAVA核心技术

    - **类与对象**:类是对具有相同属性和行为的对象的抽象,而对象则是类的一个实例。 - **方法**:函数的另一种称呼,在JAVA中称为方法,用于实现特定的功能。 - **包**:用于组织类和接口的一种方式,可以避免名称...

    Java语言与面向对象与程序设计.rar

    第4章 抽象、封装与类 !j*x,\9t9~-v1?'j;Q | 国内领先的通信技术论坛4.1 抽象与封装 (B1v*g5t"^$e'P1t H-iwww.mscbsc.com4.2 Java 的类 ,n!k+J%m9Ewww.mscbsc.com4.3 类的修饰符 E&j.X!R-|'Z;l 4.4 域 6}:O9I9h+X&...

    疯狂JAVA讲义

    学生提问:构造器是创建Java对象的途径,是不是说构造器完全负责创建Java对象? 141 5.5.2 构造器的重载 142 学生提问:为什么要用this来调用另一个重载的构造器?我把另一个构造器里的代码复制、粘贴到这个构造器...

    JAVA复习题总汇-选择题含答案 (1).docx

    这些题目涵盖了Java的一些核心概念,包括语言起源、循环结构、注释方式、数据类型转换、类与对象的使用、输入输出处理、类的修饰符、包的分类、文件操作、字符串处理以及运算符等。 1. Java的前身是Oak,这是Java...

    JAVA_Thinking in Java(中文版 由yyc,spirit整理).chm

    A.1.3 传递和使用Java对象 A.1.4 JNI和Java违例 A.1.5 JNI和线程处理 A.1.6 使用现成代码 A.2 微软的解决方案 A.3 J/Direct A.3.1 @dll.import引导命令 A.3.2 com.ms.win32包 A.3.3 汇集 A.3.4 编写回调函数 A.3.5 ...

    java 编程入门思考

    A.1.3 传递和使用Java对象 A.1.4 JNI和Java违例 A.1.5 JNI和线程处理 A.1.6 使用现成代码 A.2 微软的解决方案 A.3 J/Direct A.3.1 @dll.import引导命令 A.3.2 com.ms.win32包 A.3.3 汇集 A.3.4 编写回调函数 A.3.5 ...

    java初学者必看

    7.1.3 对象与类的关系 7.2 定义类 7.2.1 MasterCard类的实现 7.2.2 MasterCard类的使用 7.2.3 访问控制 7.2.4 构造方法 7.2.5 方法的参数 7.2.6 封装与隐藏 7.2.7 finalize()方法 7.3 静态域与静态方法 ...

Global site tag (gtag.js) - Google Analytics