精华内容
下载资源
问答
  • 主要介绍了Python面向对象程序设计之类和对象、实例变量、类变量用法,结合实例形式分析了Python面向对象程序设计中类和对象、实例变量、类变量具体功能、原理、使用方法与操作注意事项,需要的朋友可以参考下
  • 面向对象 类与对象 实例变量与实例方法 学习目标 能够理解面向对象的思想 能够明确类与对象关系 能够掌握类的定义格式 掌握实例变量的定义格式 掌握实例方法的定义格式 能够...

    内容

    • 面向对象
    • 类与对象
    • 实例变量与实例方法

    学习目标

    • 能够理解面向对象的思想

    • 能够明确类与对象关系

    • 能够掌握类的定义格式

      • 掌握实例变量的定义格式
      • 掌握实例方法的定义格式
    • 能够掌握创建对象格式,并访问类中的成员

      • 掌握通过对象访问实例变量
      • 掌握通过对象调用实例方法
    • 掌握方法的可变参数的使用

    第五章 面向对象思想

    5.1 面向对象思想概述

    1、概述

    Java语言是一种面向对象的程序设计语言,而面向对象思想(OOP)是一种程序设计思想,我们在面向对象思想的指引下,使用Java语言去设计、开发计算机程序。
    这里的对象泛指现实中一切事物,每种事物都具备自己的属性行为。面向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征抽象出来,描述成计算机事件的设计思想。
    它区别于面向过程思想(POP),强调的是通过调用对象的行为来实现功能,而不是自己一步一步的去操作实现。

    2、面向对象与面向过程的区别

    面向过程:POP: Process-Oriented Programming

    ​ 以函数(方法)为最小单位

    ​ 数据独立于函数之外

    ​ 以过程,步骤为主,考虑怎么做

    面向对象:OOP: Object Oriented Programming

    ​ 以类/对象为最小单位,类包括:数据+方法

    ​ 以对象(谁)为主,考虑谁来做,谁能做

    面向对象仍然包含面向过程,只不过关注点变了,关注谁来做

    程序员的角色:

    面向过程:程序员是具体执行者

    面向对象:程序员是指挥者

    面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者。

    例子:把大象装进冰箱

    在这里插入图片描述

    3、面向对象的基本特征

    面向对象的语言中,包含了三大基本特征,即封装、继承和多态。

    5.2 类和对象

    环顾周围,你会发现很多对象,比如桌子,椅子,同学,老师等。桌椅属于办公用品,师生都是人类。那么什么是类呢?什么是对象呢?

    什么是类

    • :是一类具有相同特性的事物的抽象描述,是一组相关属性行为的集合。可以看成是一类事物的模板,使用事物的属性特征和行为特征来描述该类事物。

    现实中,描述一类事物:

    • 属性:就是该事物的状态信息。
    • 行为:就是该事物能够做什么。

    举例:小猫。

    ​ 属性:名字、体重、年龄、颜色。
    ​ 行为:走、跑、叫。

    什么是对象

    • 对象:是一类事物的具体体现。对象是类的一个实例(对象并不是找个女朋友),必然具备该类事物的属性和行为。

    现实中,一类事物的一个实例:一只小猫 。

    举例:一只小猫。

    ​ 属性:tom、5kg、2 years、yellow。
    ​ 行为:溜墙根走、蹦跶的跑、喵喵叫。

    类与对象的关系

    • 类是对一类事物的描述,是抽象的
    • 对象是一类事物的实例,是具体的
    • 类是对象的模板,对象是类的实体
      在这里插入图片描述

    5.3 类的定义和对象的创建

    事物与类的对比

    现实世界的一类事物:

    属性:事物的状态信息。
    行为:事物能够做什么。

    Java中用class描述事物也是如此:

    成员变量:对应事物的属性
    成员方法:对应事物的行为

    类的定义格式

    public class ClassName {
      //成员变量
      //成员方法 
    }
    
    • 定义类:就是定义类的成员,包括成员变量成员方法
    • 成员变量:和以前定义变量几乎是一样的。只不过位置发生了改变。在类中,方法外
    • 成员方法:和以前写的main方法格式类似。只不过功能和形式更丰富了。在类中,方法外。

    类的定义格式举例:

    public class Person {
      	//成员变量
      	String name;//姓名
        int age;//年龄
        boolean isMarried;
        
        public void walk(){
            System.out.println("人走路...");
        }
        public String display(){
            return "名字是:" + name + ",年龄是:" + age + ",Married:" + isMarried;
        }
    }
    

    在这里插入图片描述

    对象的创建

    创建对象:

    new 类名()//也称为匿名对象
    
    //给创建的对象命名
    //或者说,把创建的对象用一个引用数据类型的变量保存起来
    类名 对象名 = new 类名();
    

    类似于:

    System.out.println("柴老师年龄是:" + 18);//如果确定只在这里一次性使用,那么可以不用变量保存(#^.^#)
    
    //把18用int类型的age变量保存起来,方便后面使用
    int age = 18;
    System.out.println("柴老师年龄是:" + age);
    System.out.println("宋老师比柴老师大10岁,年龄是:" + (age+10));
    

    那么,对象名中存储的是什么呢?答:对象地址

    class Student{
        
    }
    public class TestStudent{
        //Java程序的入口
        public static void main(String[] args){
            System.out.println(new Student());//Student@7852e922
    
            Student stu = new Student();
            System.out.println(stu);//Student@4e25154f
            
            int[] arr = new int[5];
    		System.out.println(arr);//[I@70dea4e
        }
    }
    //Student和TestStudent没有位置要求,谁在上面谁在下面都可以
    //但是如果TestStudent类的main中使用了Student类,那么要求编译时,这个Student已经写好了,不写是不行的
    //如果两个类都在一个.java源文件中,只能有一个类是public的
    

    发现学生对象和数组对象类似,直接打印对象名和数组名都是显示“类型@对象的hashCode值",所以说类、数组都是引用数据类型,引用数据类型的变量中存储的是对象的地址,或者说指向堆中对象的首地址。
    在这里插入图片描述

    5.4 成员变量

    1、成员变量的分类

    实例变量:也叫对象属性,属于某个对象的,通过对象来使用

    类变量:也叫类变量,属于整个类的,不是属于某个实例,后面static部分讲解。

    2、如何声明实例变量?

    【修饰符】 class 类名{
        【修饰符】 数据类型  属性名;    //属性有默认值
        【修饰符】 数据类型  属性名 =; //属性有初始值
    }
    

    说明:属性的类型可以是Java的任意类型,包括基本数据类型、引用数据类型(类、接口、数组等)

    3、如何使用实例变量?

    (1)实例变量在本类的实例方法中,直接使用。

    class Circle{
        double radius;
        
        public double getArea(){
            return 3.14 * radius * radius;
        }
    }
    

    (2)实例变量在其他类的方法中,需要通过“对象名.实例变量"的方式使用

    public class TestCircle{
    	public static void main(String[] args){
    		Circle c = new Circle();
    		System.out.println("c这个圆的半径是:" + c.radius);
    		
    		//修改c这个圆的半径
    		c.radius = 1.2;
    		System.out.println("c这个圆的半径是:" + c.radius);
    	}
    }
    

    4、实例变量的特点

    (1)成员变量的默认值

    基本类型 整数(byte,short,int,long) 0
    浮点数(float,double) 0.0
    字符(char) ‘\u0000’
    布尔(boolean) false
    数据类型 默认值
    引用类型 数组,类,接口 null

    (2)实例变量的值是每个对象独立的

    class Circle{
        double radius;
    }
    public class TestCircle{
    	public static void main(String[] args){
    		Circle c1 = new Circle();
    		Circle c2 = new Circle();
    		System.out.println("c1这个圆的半径是:" + c1.radius);//0.0
    		System.out.println("c2这个圆的半径是:" + c2.radius);//0.0
    		
    		//修改c1这个圆的半径的值
    		c1.radius = 1.2;
    		System.out.println("c1这个圆的半径是:" + c1.radius);//1.2
    		System.out.println("c2这个圆的半径是:" + c2.radius);//0.0		
    	}
    }
    

    5、如何给实例变量赋值?

    (1)在声明属性时显式赋值,那么每一个对象创建之后,这个属性就不是默认值,而是这个初始值了

    【修饰符】 class 类名{
        【修饰符】 数据类型  属性名 =; //属性有初始值
    }
    

    代码示例:

    class Student{
        String name;
        char gender = '男';//显式赋值
    }
    
    class TestStudent{
        public static void main(String[] args){
            Student s1 = new Student();
            System.out.println("姓名:" + s1.name);//null
            System.out.println("性别:" + s1.gender);//男
            
            s1.name = "小薇";//修改属性的默认值
            s1.gender = '女';//修改属性的初始值
            System.out.println("姓名:" + s1.name);//小薇
            System.out.println("性别:" + s1.gender);//女
            
            Student s2 = new Student();
            System.out.println("姓名:" + s2.name);//null
            System.out.println("性别:" + s2.gender);//男
        }
    }
    

    (2)通过对象为属性赋值

    //为对象的属性赋值
    对象名.属性名 =;
    

    6、实例变量内存图

    class Student{
        String name;
        char gender = '男';//显式赋值
    }
    
    class TestStudent{
        public static void main(String[] args){
            Student s1 = new Student();
            System.out.println("姓名:" + s1.name);//null
            System.out.println("性别:" + s1.gender);//男
            
            s1.name = "小薇";
            s1.gender = '女';
            System.out.println("姓名:" + s1.name);//小薇
            System.out.println("性别:" + s1.gender);//女
            
            Student s2 = new Student();
            System.out.println("姓名:" + s2.name);//null
            System.out.println("性别:" + s2.gender);//男
        }
    }
    

    在这里插入图片描述

    7、实例变量和局部变量区别

    变量根据定义位置的不同,我们给变量起了不同的名字。如下图所示:

    • 在类中的位置不同 重点
      • 实例变量:类中,方法外

      • 局部变量:方法中或者方法声明上(形式参数)

    在这里插入图片描述

    • 作用范围不一样 重点
      • 实例变量:类中直接用,其他类通过"对象名.实例变量"使用
      • 局部变量:当前方法的作用域中
    • 初始化值的不同 重点
      • 实例变量:有默认值
      • 局部变量:没有默认值。必须先定义,赋值,最后使用
    • 在内存中的位置不同 了解
      • 实例变量:堆内存
      • 局部变量:栈内存
    • 生命周期不同 了解
      • 实例变量:随着对象的创建或者类的加载而存在,随着对象的消失而消失
        • 换句话说,没有创建对象,就不会在堆中分配它的内存,创建一个,分配一个
      • 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
        • 换句话说,方法没有被调用,该局部变量不会在栈中分配内存,调用一次,分配一次

    8、实例变量的练习

    练习一:声明矩形类

    需求:声明矩形类,包含长、宽两个实例变量,并创建矩形对象,求面积

    public class Field_Demo1 {
    	public static void main(String[] args) {
    		//创建对象
    		Rectangle r = new Rectangle();
    		r.length = 1;
    		r.width = 2;
    		System.out.println("长:" + r.length);
    		System.out.println("宽:" + r.width);
    		System.out.println("面积:" + r.length*r.width);
    	}
    }
    class Rectangle{
    	double length;
    	double width;
    }
    

    练习二:声明员工类

    需求:声明员工类,包含姓名、性别、薪资三个实例变量,并创建员工对象,打印信息

    public class Field_Demo2 {
    	public static void main(String[] args) {
    		//创建对象
    		Employee emp = new Employee();
    		emp.name = "柴林燕";
    		emp.gender = '女';
    		emp.salary = 10000;
    		System.out.println("姓名:" + emp.name);
    		System.out.println("性别:" + emp.gender);
    		System.out.println("薪资:" + emp.salary);
    	}
    }
    class Employee{
    	String name;
    	char gender;
    	double salary;
    }
    

    练习三:声明日期类

    需求:声明日期类,包含年、月、日三个实例变量,并创建日期对象,显示信息

    public class Field_Demo3 {
    	public static void main(String[] args) {
    		//创建对象
    		MyDate today = new MyDate();
    		today.year = 2019;
    		today.month = 7;
    		today.day = 5;
    		System.out.println("今天是" + today.year + "年" + today.month + "月" + today.day);
    	}
    }
    class MyDate{
    	int year;
    	int month;
    	int day;
    }
    

    练习四:声明丈夫和妻子类

    需求:

    丈夫类:包含姓名和妻子属性

    妻子类:包含姓名和丈夫属性

    创建一对夫妻对象,并打印信息

    public class Field_Demo4 {
    	public static void main(String[] args) {
    		//创建丈夫对象
    		Husband husband = new Husband();
    		//创建妻子对象
    		Wife wife = new Wife();
    		//指定属性
    		husband.name = "邓超";
    		wife.name = "孙俪";
    		husband.wife = wife;
    		wife.husband = husband;
    		
    		System.out.println("丈夫:" + husband.name + ",他妻子是:" + husband.wife.name);
    		System.out.println("妻子:" + wife.name + ",他丈夫是:" + wife.husband.name);
    	}
    }
    class Husband{
    	String name;
    	Wife wife;
    }
    class Wife{
    	String name;
    	Husband husband;
    }
    

    在这里插入图片描述

    5.5 成员方法

    5.5.1 方法的概念

    方法也叫函数,是一个独立功能的定义,是一个类中最基本的功能单元。

    把一个功能封装为方法的目的是,可以实现代码重用,从而简少代码量。

    5.5.2 方法的原则

    方法的使用原则:

    (1)必须先声明后使用

    类,变量,方法等都要先声明后使用

    (2)不调用不执行,调用一次执行一次。调用一次,在栈中压入一个方法栈。

    5.5.3 成员方法的分类

    成员方法分为两类:

    • 实例方法:属于对象的方法,由对象来调用。
    • 静态方法:也叫类方法,属于整个类的,不是属于某个实例,由类名来调用,后面static部分讲解。

    5.5.4 定义实例方法的格式详解

    1、语法格式

    修饰符 返回值类型 方法名(【参数列表:参数类型1 参数名1,参数类型2 参数名, ......){
            方法体;
            【return 返回值;}
    
    • 修饰符: public 目前固定写法,没有学习其他修饰符
    • 返回值类型: 表示方法运行的结果的数据类型,方法执行后将结果返回到调用者
      • 基本数据类型
      • 引用数据类型
      • 无返回值类型:void
    • 方法名:给方法起一个名字,见名知意,能准确代表该方法功能的名字
    • 参数列表:方法内部需要用到其他方法中的数据,需要通过参数传递的形式将数据传递过来,可以是基本数据类型、引用数据类型、也可以没有参数,什么都不写
    • 方法体:特定功能代码
    • return:结束方法,并将方法的结果返回去,
      • 如果返回值类型不是void,方法体中必须保证一定有return 返回值;语句,并且要求该返回值结果的类型与声明的返回值类型一致或兼容。
      • 如果返回值类型为void时,return 后面不用跟返回值,甚至也可以没有return语句。
      • return语句后面就不能再写其他代码了,否则会报错:Unreachable code

    2、方法声明的位置必须在类中方法外

    正确示例:

    {
        方法1(){
            
        }
        方法2(){
            
        }
    }
    

    错误示例:

    {
        方法1(){
            方法2(){  //错误
            
       		}
        }
    }
    

    5.5.5 实例方法调用

    • 方法调用的位置:在另一个方法中调用。

      正确示例:

      {
          方法1(){
              调用其他方法;
          }
      }
      
    • 方法调用的分类:

      • 单独调用,格式如下:

        对象名.方法名(参数)
      • 输出或返回调用,格式如下:

        System.out.println(对象名.方法名(参数));//直接输出方法调用后的返回值return 对象名.方法名(参数);//直接返回方法调用后的返回值作为当前方法的返回值
        
      • 赋值调用,格式如下:

        数据类型 变量名 = 对象名.方法名(参数);
        

    如果实例方法是在本类的另一个实例方法中调用,那么可以省略“对象名.”

    class Count {
        /*
        定义计算两个整数和的方法
        返回值类型,计算结果是int
        参数:不确定数据求和,定义int参数.参数又称为形式参数
        */
        public int getSum(int a, int b) {
            return a + b;
        }
        
        /*
        定义计算两个整数差的方法
        返回值类型,计算结果是int
        参数:不确定数据求差,定义int参数.参数又称为形式参数
        */
        public int getSubtract(int a, int b){
            return getSum(a,-b);//直接返回getSum(a,-b)方法调用的结果作为getSubtract(a,b)的结果
        }
    }
    
    public class Method_Demo1 {
        public static void main(String[] args) {
            // 创建对象
            Count c = new Count();
            
            // 通过单独调用方式调用方法
            c.getSum(3,4)// 通过输出调用方式调用方法
            System.out.println(c.getSum(3,4));
            
            // 通过赋值调用方式调用方法
            int sum = c.getSum(3,4);
            System.out.println(sum);
        }
    }
    
    • 形参:在定义方法时方法名后面括号中的变量名称称为形式参数(简称形参),即形参出现在方法定义中。
    • 实参:调用者方法中调用另一个方法时,方法名后面括号中的参数称为实际参数(简称实参),即实参出现在调用者方法中。

    总结:

    (1)调用时,需要通过方法名来识别调用哪个方法

    (2)调用时,需要传“实参”,实参的个数、类型、顺序顺序要与形参列表一一对应

    ​ 如果方法没有形参,就不需要也不能传实参。

    (3)调用时,如果方法有返回值,可以接受或处理返回值结果。

    ​ 如果方法的返回值类型是void,不需要也不能接收和处理返回值结果。

    5.5.6 定义和调用实例方法练习

    练习一:比较两个整数是否相同

    • 分析:定义方法实现功能,需要有两个明确,即返回值参数列表
      • 明确返回值:比较整数,比较的结果只有两种可能,相同或不同,因此结果是布尔类型,比较的结果相同为true。
      • 明确参数列表:比较的两个整数不确定,所以默认定义两个int类型的参数。
    class Count {
        /*
            定义比较两个整数是否相同的方法
            返回值类型,比较的结果布尔类型
            参数:不确定参与比较的两个整数
        */
        public boolean compare(int a, int b) {
            if (a == b) {
                return true;
            } else {
                return false;
            }
        }
    }
    
    public class Method_Exer1 {
        public static void main(String[] args) {
            // 创建对象
            Count c = new Count();
            
            //调用方法compare,传递两个整数
            //并接收方法计算后的结果,布尔值
            boolean bool = c.compare(3, 8);
            System.out.println(bool);
        }
    }
    

    练习二:计算两个整数的最大值

    • 分析:定义方法实现功能,需要有两个明确,即返回值参数列表
      • 明确返回值:比较整数,比较的结果是它们中的一个,所以是int。
      • 明确参数列表:比较的两个整数不确定,所以默认定义两个int类型的参数。
    class Count{
    	public int max(int a,int b){
    		return a>b?a:b;
    	}
    }
    public class Method_Exer2{
    	public static void main(String[] args) {
    		java.util.Scanner input = new java.util.Scanner(System.in);
    		System.out.print("请输入一个整数:");
    		int x = input.nextInt();
    		
    		System.out.print("请输入另一个整数:");
    		int y = input.nextInt();
    		
    		Count c = new Count();
    		int max = c.max(x, y);
    		System.out.println(x + "," + y + "中的最大值是:" + max);
    	}
    }
    

    练习三:计算1+2+3…+100的和

    • 分析:定义方法实现功能,需要有两个明确,即返回值参数
      • 明确返回值:1~100的求和,计算后必然还是整数,返回值类型是int
      • 明确参数:需求中已知到计算的数据,没有未知的数据,不定义参数
    class Count {
    	/*
            定义计算1~100的求和方法
            返回值类型,计算结果整数int
            参数:没有不确定数据
        */
        public int getSum() {
            //定义变量保存求和
            int sum = 0;
            //从1开始循环,到100结束
            for (int i = 1; i <= 100; i++) {
                sum = sum + i;
            }
            return sum;
        }
    }
    
    public class Method_Exer3 {
        public static void main(String[] args) {
            // 创建对象
            Count c = new Count();
            
            //调用方法getSum
            //并接收方法计算后的结果,整数
            int sum = c.getSum();
            System.out.println(sum);
        }
    }
    

    练习四:实现不定次数打印HelloWorld

    • 分析:定义方法实现功能,需要有两个明确,即返回值参数
      • 明确返回值:方法中打印出HelloWorld即可,没有计算结果,返回值类型void
      • 明确参数:打印几次不清楚,参数定义一个整型参数
    class PrintUtil {
    	/*
              定义打印HelloWorld方法
              返回值类型,计算没有结果 void
              参数:不确定打印几次
        */
        public void printHelloWorld(int n) {
            for (int i = 0; i < n; i++) {
                System.out.println("HelloWorld");
            }
        }
    }
    
    public class Method_Exer4 {
        public static void main(String[] args) {
            // 创建对象
            PrintUtil p = new PrintUtil();
            
            //调用方法printHelloWorld,传递整数
            p.printHelloWorld(9);
        }
    }
    

    练习五:实现打印不确定(行数、列数、组成的符号)矩形的图形

    • 分析:定义方法实现功能,需要有两个明确,即返回值参数
      • 明确返回值:方法中打印出line行column列由sign组成的矩形即可,没有计算结果,返回值类型void
      • 明确参数:打印几行,几列,什么符号组成不清楚,参数定义三个参数
    public class Method_Exer5 {
    	public static void main(String[] args) {
    		//创建对象
    		PrintUtil pu = new PrintUtil();
    		
    		//调用printRectangle方法
    		pu.printRectangle(5, 10, "&");
    	}
    }
    class PrintUtil{
    	public void printRectangle(int line, int column, String sign){
    		for (int i = 0; i < line; i++) {
    			for (int j = 0; j < column; j++) {
    				System.out.print(sign);
    			}
    			System.out.println();
    		}
    	}
    }
    

    练习六:声明圆类

    • 需求:声明一个圆

      • 包含实例变量radius保存圆对象半径的值
      • 包含实例方法getArea求圆对象的面积
      • 包含实例方法getPerimeter求圆对象的周长
      • 包含实例方法getInfo获取圆对象的详细信息
    • 分析:定义方法实现功能,需要有两个明确,即返回值参数

      • 明确返回值
        • getArea()方法需要返回面积值,所以是double类型
        • getPerimeter()方法需要返回周长值,所以是double类型
        • getInfo()方法需要返回圆对象的完整信息,所以是String类型
      • 明确参数
        • getArea()方法,求面积值通过实例变量radius计算即可,所以不需要再设计参数
        • getPerimeter()方法,求周长通过实例变量radius计算即可,所以不需要再设计参数
        • getInfo()方法,返回圆对象的完整信息,由实例变量radius的值,和通过getArea()方法计算的面积值,通过getPerimeter()方法计算的周长的值组成,所以不需要再设计参数
    public class Method_Exer6 {
    	public static void main(String[] args) {
    		//创建对象
    		Circle c = new Circle();
    		c.radius = 1.2;
    		System.out.println(c.getInfo());
    	}
    }
    class Circle{
    	double radius;
    	
    	public double getArea(){
    		return 3.14 * radius * radius;
    	}
    	
    	public double getPerimeter(){
    		return 2 * 3.14 * radius;
    	}
    	
    	public String getInfo(){
    		return "半径:" + radius + ",面积:" + getArea() + ",周长:" + getPerimeter();
    	}
    }
    

    练习七:声明客户和账户类、银行类

    • 声明账户类Account

      • 包含:账户和余额两个实例变量
      • 包含save存款方法
      • 包含withdraw取款方法
    • 声明客户类Customer

      • 包含:姓名和手机、身份证号、拥有的一个账户,四个实例变量
    • 声明银行类BankClerk

      • 包含open方法,给某个客户对象开户,关联Customer和Account两个对象的信息
    class Account{
    	String id;
    	double balance;
    	public void save(double money){
    		if(money > 0){
    			balance += money;
    		}else{
    			System.out.println("参数有误");
    		}
    	}
    	public void withdraw(double money){
    		if(money <0){
    			System.out.println("参数有误");
    		}else if(money > balance){
    			System.out.println("余额不足");
    		}else{
    			balance -= money;
    		}
    	}
    }
    class Customer{
    	String name;
    	String tel;
    	String cid;
    	Account account;
    }
    class BankClerk{
    	public void open(Customer c, Account a){
    		c.account = a;
    	}
    }
    public class Method_Exer6 {
    	public static void main(String[] args) {
    		//创建客户对象
    		Customer c = new Customer();
    		c.name = "柴林燕";
    		c.tel = "10086";
    		c.cid = "111111111111111111";
    		
    		//创建银行卡账号对象
    		Account a = new Account();
    		a.id = "12345678910";
    		a.balance = 0;
    		
    		//银行对象
    		BankClerk b = new BankClerk();
    		b.open(c, a);
    		System.out.println("姓名:" + c.name + ",电话:" + c.tel + ",身份证号:" + c.cid + ",账号:" + c.account.id + ",余额:" + c.account.balance);
    		
    		//存款
    		c.account.save(1000);
    		System.out.println("姓名:" + c.name + ",电话:" + c.tel + ",身份证号:" + c.cid + ",账号:" + c.account.id + ",余额:" + c.account.balance);
    		
    		//取款
    		c.account.withdraw(2000);
    		//显示信息
    		System.out.println("姓名:" + c.name + ",电话:" + c.tel + ",身份证号:" + c.cid + ",账号:" + c.account.id + ",余额:" + c.account.balance);
    	}
    }
    

    5.5.7 可变参数

    JDK1.5之后,如果我们定义一个方法时,此时某个形参的类型可以确定,但是形参的个数不确定,那么我们可以使用可变参数。

    格式:

    修饰符 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型... 形参名){  }
    

    要求:

    (1)一个方法只能有一个可变参数

    (2)可变参数必须是形参列表的最后一个

    (3)其实这个书写“等价于”

    修饰符 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型[] 形参名){  }
    

    只是后面这种定义,在调用时必须传递数组,而前者更灵活,既可以传递数组,又可以直接传递数组的元素,其实编译成的class文件,将这些元素先封装到一个数组中,在进行传递。这些动作都在编译.class文件时,自动完成了。

    好处:

    同样是代表数组,但是在调用这个带有可变参数的方法时,不用创建数组(这就是简单之处),直接将数组中的元素作为实际参数进行传递,其实编译成的class文件,将这些元素先封装到一个数组中,在进行传递。这些动作都在编译.class文件时,自动完成了。

    代码演示:

    public class ChangeArgs {
    	public static void main(String[] args) {
    		// 创建对象
    		Count c = new Count();
    
    		int[] arr = { 1, 4, 62, 431, 2 };
    		int sum1 = c.getSum1(arr);
    		System.out.println(sum1);
    
    		int sum2 = c.getSum2(arr);
    		System.out.println(sum2);
    		int sum3 = c.getSum2(1, 4, 62, 431, 2);
    		System.out.println(sum3);
    	}
    
    }
    
    class Count {
    
    	// 完成数组 所有元素的求和
    	// 原始写法
    	public int getSum1(int[] arr) {
    		int sum = 0;
    		for (int i = 0; i < arr.length; i++) {
    			sum += arr[i];
    		}
    
    		return sum;
    	}
    
    	// 可变参数写法
    	public int getSum2(int... arr) {
    		int sum = 0;
    		for (int i = 0; i < arr.length; i++) {
    			sum += arr[i];
    		}
    		return sum;
    	}
    }
    

    练习一:找最大值

    定义求1-n个整数中的最大值

    public class ChangeArgs_Exer1 {
    	public static void main(String[] args) {
    		Count c = new Count();
    		System.out.println(c.max(1));
    		System.out.println(c.max(5,3,2,6));
    	}
    }
    class Count{
    	public int max(int num, int... others){
    		int max = num;
    		for (int i = 0; i < others.length; i++) {
    			if(max < others[i]){
    				max = num;
    			}
    		}
    		return max;
    	}
    }
    

    练习二:字符串拼接

    定义将n个字符串进行拼接,如果没有传入字符串,那么返回空字符串

    public class ChangeArgs_Exer2 {
    	public static void main(String[] args) {
    		StringUtil su = new StringUtil();
    		System.out.println(su.concat());
    		System.out.println(su.concat("hello","world"));
    	}
    }
    class StringUtil{
    	public String concat(String... args){
    		String str = "";
    		for (int i = 0; i < args.length; i++) {
    			str += args[i];
    		}
    		return str;
    	}
    }
    

    练习三:字符串拼接2

    定义将n个字符串进行拼接,每一个字符串之间使用某字符进行分割,如果没有传入字符串,那么返回空字符串

    public class ChangeArgs_Exer4 {
    	public static void main(String[] args) {
    		StringUtil su = new StringUtil();
    		System.out.println(su.concat('+'));
    		System.out.println(su.concat('+',"hello","world"));
    	}
    }
    class StringUtil{
    	public String concat(char seperator, String... args){
    		String str = "";
    		for (int i = 0; i < args.length; i++) {
    			if(i==0){
    				str += args[i];
    			}else{
    				str += seperator + args[i];
    			}
    		}
    		return str;
    	}
    }
    
    展开全文
  • 概念:面向对象 ,类.类是抽象的,类具有的所有的公共属性(数据属性,函数属性).对象是具体的打个比方说,类是学校,而对象是具体的学校(比如清华)面向对象设计(函数的形式) def school(name,addr,number): #只有学校能...
    概念:

    面向对象 ,类.类是抽象的,类具有的所有的公共属性(数据属性,函数属性).对象是具体的
    打个比方说,类是学校,而对象是具体的学校(比如清华)


    面向对象设计(函数的形式)
    def school(name,addr,number):     #只有学校能调用该school方法,防止其他类(人啊,物啊等)调用学校的属性
        def init(name,addr,number):
            date = {
                'name':name,
                'addr':addr,              #这里定义了一个函数作用域,防止函数外部访问函数内的变量
                'number':number,
                'Zhao_Sheng':Zhao_Sheng
            }
            return date
        def Zhao_Sheng(name):
            print('%s学校招生了'%name)
        return init(name,addr,number)
    sch1 = school('清华','北京',10000)
    print(sch1['name'])
    sch1['Zhao_Sheng']('清华')


    面向对象,类变量与实例变量,实例化
    类属性分为2种:数据属性与函数属性
    对象只有数据属性(通过构造方法__init__设置),没有函数属性.
    class school:   #class关键字,申明一个类
        country= 'china'   #在类下直接定义变量为类变量,与对象无关
        def __init__(self,name,addr,munber):  #执行class时,__init__函数自动执行,__init__内的变量为实例变量
            self.name = name
            self.addr = addr
            self.munber = munber
        def Zhao_Sheng(self):   #self这个参数是实例化时具体的对象
            print('%s开始招生了'%self.name)
    sch2 = school('北大','北京',5000)   #实例化
    print(school.__dict__)
    print(sch2.__dict__)   #__dict__查看该类(实例)的变量
    print(school.country)    #以类的形式访问类变量
    print(sch2.country)   #对象访问类变量(作用域:对象访问变量,先找实例变量,找不到,再找类变量(类不能访问实例变量))
    print(sch2.__dict__)   #{'name': '北大', 'addr': '北京', 'munber': 5000}
    print(sch2.name)
    sch2.Zhao_Sheng()
    school.Zhao_Sheng(sch2)  #类调用函数(将sch2 传入 self),得到的结果与sch2.Zhao_Sheng()相同

    类变量的增删改查 实质是对类的属性字典进行增删改查
    class people:
        name = 'jiang'
        age = 18
        def Eat(self):
            print('真好吃')
    people1 = people()  #实例化时 ()不要忘记加
    people.sex = 'man'    #增加了类的新变量 sex = 'man'
    print(people1.sex)
    people.name = 'xuangyuan'    #改变类name
    print(people1.name)
    def Eat(self):          #类中的函数也是一个变量,也可以增删改查
        print('好难吃')
    people.Eat = Eat
    people1.Eat()
    del people.name  #删除类类变量name

    实例也可以对实例变量进行增删改查(与类类似) 如p1.name = 'shengnong',就是将原来的name改为'shengnong'

    变量易错点
    country = 'china'
    class guojia:
        country = 'japan'
        def __init__(self):      #调用实例变量与类变量用 . 号调用, .号调用只作用在该类中
            print('---->',country)  #这个prin函数中的country直接是变量,遵循变量作用域原则  #如果在__init__内添加country,那么打印的就是__init__内的值
    guojia1 = guojia()   #----> 运行构造方法,变量country不是通过.号的形式调用,所以调用全局变量中的country
    print(guojia1.country)   #japan

     

    转载于:https://www.cnblogs.com/jiangxiaolong-1996/p/9302318.html

    展开全文
  • 面向对象自我感觉是每门语言中最重要也是最难的地方,在这里给大家解释一下python面向对象中self , 对象,实例变量,类变量 我们先创建一个类: class MyClass(): """ MyClass 是一个类 """ def my_function...

    面向对象自我感觉是每门语言中最重要也是最难的地方,在这里给大家解释一下python面向对象中self , 对象,实例变量,类变量

    我们先创建一个类:

    class MyClass():
        """
        MyClass 是一个类
        """
        def my_function(self):
            """
            my_function 是一个方法
            """
            print("这个方法没有参数")
    
    
    t1=MyClass()
    # t1 是一个实例
    # MyClass() 是一个对象
    
    t1.my_function()
    # 输出:这个方法没有参数
    

    这样一个类就创建成功了,如果我们需要知道是谁在调用my_function该如何实现呢?(在这里它是类的方法,我们需要在类上面去接收参数),具体看以下代码

    # author:别动我名字
    # contact: 172212595@qq.com
    # datetime:2019/4/9 23:29
    # software: PyCharm Community Edition
    
    """
    文件说明: 这里给大家解释一下self , 对象,实例变量,类变量
    
    """
    
    
    class MyClass():
        """
        MyClass 是一个类
        """
    
        def __init__(self, name):
            """
            init是构造函数,在实例化对象的时候初始化数据(创建对象的时候会先运行这个方法)
            """
            self.name = name # 这是实例变量,作用域就是实例本身 相当于 t1.name = name
    
        def my_function(self):
            """
            my_function 是一个方法
            """
            print("%s在调用这个方法" % self.name)
    
    
    t1 = MyClass('张三') # 这里只传了"张三",但实际上 程序会把"t1"也传过去, self接手
    # t1 是一个实例
    # MyClass() 是一个对象
    
    t1.my_function()
    # 输出:张三在调用这个方法
    
    

    其实python中的self与Java中的this是一样的东西,我们也可以将python中的self写成this。运行结果完全一样。当然,最好还是尊重约定俗成的习惯,使用self。

    类变量、实例变量

    # author:别动我名字
    # contact: 172212595@qq.com
    # datetime:2019/4/9 23:29
    # software: PyCharm Community Edition
    
    """
    文件说明: 这里给大家解释一下self , 对象,实例变量,类变量
    
    """
    
    
    class MyClass():
        """
        MyClass 是一个类
        """
        n=123 # 这是一个类变量
        name='我是类变量' # 这也是类变量 
        def __init__(self, name):
            """
            init是构造函数,在实例化对象的时候初始化数据(创建对象的时候会先运行这个方法)
            """
            self.name = name # 这是实例变量
    
        def my_function(self):
            """
            my_function 是一个方法
            """
            print("n=%s"%self.n)
            print("%s在调用这个方法" % self.name)
    # 对象被实例化后会先找实例变量,没有实例变量,才会找类变量。所以这里不会走类变量
    
    
    t1 = MyClass('张三')
    t1.my_function()
    # 输出:
    # n=123
    # 张三在调用这个方法  
    
    

    类变量是类里面方法共用的属性

    展开全文
  • 1. 要写出有意义的面向对象的代码,最核心的:类、对象。三大特性:继承、封装、多态类变量与实例变量:class Student():# 类变量name = "张"age = 0def __init__(self, name, age):# 构造函数# 初始化...

    1. 要写出有意义的面向对象的代码,最核心的:类、对象。三大特性:继承、封装、多态

    类变量与实例变量:

    class Student():

    # 类变量

    name = "张"

    age = 0

    def __init__(self, name, age):

    # 构造函数

    # 初始化变量的属性

    self.name = name

    self.age = age

    student1 = Student("王",2)

    print(student1.name)

    print(Student.name)

    ######结果:

    ########通过这个例子,能看出来实例化的时候,类变量并没有改变。

    class Student():

    def __init__(self, name, age):

    # 构造函数

    # 初始化变量的属性

    self.name = name

    self.age = age

    student1 = Student("王",2)

    print(student1.name)

    ######结果:

    ########对比发现实例变量和类变量的区别

    在来看一个变量的问题

    class Student():

    # 类变量

    name = "张"

    age = 0

    def __init__(self, name, age):

    # 构造函数

    # 初始化变量的属性

    name = name

    age = age

    student1 = Student("王",2)

    print(student1.name)

    print(student1.__dict__)

    print(Student.name)

    print(Student.__dict__)

    ######结果:

    {}(此时说明student1是空的,但是Python的机制是他会向上寻找(去类里面寻找)一个和实例变量名字相同的变量(如果里面没有,会去类的父类里寻找),这就解释了为什么打印出“张”)

    {"__module__": "__main__", "name": "张", "age": 0, ···}

    12. self:方法中必须传入self,self就是调用方法的对象,只和对象有关,代表实例。

    13. 访问类变量:Student.sum、self.__class__.sum

    展开全文
  • 类变量和实例变量的区别 1、类变量由所有实例共享。 2、实例变量由实例单独享有,不同实例之间不影响。 3、当我们需要在一个类的不同实例之间共享变量的时候使用类变量。 class Person(): country = "china...
  • 类变量和实例变量又是什么?类方法中如何访问类变量、类方法要如何调用?当然实例方法中如何访问类变量?能实例方法访问实例变量,实例方法如何被调用?当然类方法中能否访问实例变量?不能对象调用类方法?能静态...
  • **本文内容** 面向对象 ...Java语言是一种面向对象的程序设计语言,而面向对象思想(OOP)是一种程序设计思想,我们在面向对象思想的指引下,使用Java语言去设计、开发计算机程序。 这里的对象泛指现实..
  • 1. 要写出有意义的面向对象的代码,最核心的:类、对象。三大特性:继承、封装、多态类变量与实例变量:class Student():# 类变量name = ‘张‘age = 0def __init__(self, name, age):# 构造函数# 初始化变量的属性...
  • 类和对象: 类的定义:用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。...对象包括两个数据成员(类变量和实例变量)和方法。 使用 class 语句来创建一个新类: class ...
  • 本节内容 面向对象编程介绍 为什么用面向对象进行开发 面向对象的特性:封装,继承,多态 类,属性,方法,构造函数,析构函数 类变量,实例变量 ...
  • 成员变量又分为实例变量和类变量 成员方法又分为实例方法、类方法和静态方法 - 成员变量(attribute) :实例变量、类变量 类成员 - 属性(property) - 成员方法 : 实例方法、类方法、静态方法 成员变量 是类中...
  • 类变量是指是指该类的所有实例说共有的数据,实例变量是该类每一个实例所特有的数据。这么说的话可能还是很抽象,我们拿人类(Person类)来打比方,人类能移动(move=True),这是每一个人(张三、李四)都能做的,所以...
  • 类对象和实例对象  Python中一切皆对象,Python类本身也是一种对象,类... 如果说类时一种概念性的定义,是一种类别,那么实例对象就是对这一类别的具体化、实例化,即实例化对象是类对象实例化之后的产物。 cla...
  • ⑵、static在java中声明成员变量时这个变量也叫作类变量也称静态变量,这个变量是属于类的,而不属于某一实际的对象实例改变任意一个实例中的类变量其他的实例也会受到影响;不用static声明的成员变量也叫作非静态...
  • 1. 要写出有意义的面向对象的代码,最核心的:类、对象。三大特性:继承、封装、多态类变量与实例变量:class Student():# 类变量name = '张'age = 0def __init__(self, name, age):# 构造函数# 初始化变量的属性...
  • 1 class Role(object):#执行时之后... 2 n='我是类里的n' #类变量,保存在类的内存里 3 list=[] 4 name='我是类里的name' 5 def __init__(self,name,role,weapon,life_value=100,money=15000): 6 #构造函数...
  • 面向对象编程概述:Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的.面向对象技术简介类(Class): 用来...类变量通常不作为实例变量使用。数据成员:类变量或者实...
  • 1. 类对象和实例对象  Python中一切皆对象,Python类本身也是一种对象,类定义完成后,会在... 如果说类时一种概念性的定义,是一种类别,那么实例对象就是对这一类别的具体化、实例化,即实例化对象是类对象实例...
  • 本文实例分析了JavaScript面向对象之私有静态变量。分享给大家供大家参考,具体如下: 大家知道,私有实例变量的原理是根据作用域。 私有实例变量是在Javascript的function内部用var关键字实现,只在function内部...
  • 1. 要写出有意义的面向对象的代码,最核心的:类、对象。三大特性:继承、封装、多态类变量与实例变量: class Student(): # 类变量 name = '张' age = 0 def __init__(self, name, age): # 构造函数 # ...
  • 在 @interface 和 @end 中间 用大括号括起来 写上 实例变量 然后再大括号的外边声明 set get 方法 .m文件中 这里以 name为例子 写他们的get set 方法 的实现 在@implementation和 @end中间写 ...
  • ⼜称为实例⽅法. 总之这样的东西 需要⽤对象来访问. ⽽上方的self.属性1 = 参数1 这个代码的含义是给对象设置属性信息. 含义是这个对象的xxx属性是xxxx. 这种东西⼜被称之为成员变量或者实例变量, 再或者被称之 为...
  • 用于处理分数的Objective-C类的基础上,增加... 的实例方法,来实现对实例变量的检索。 之前,我们已经知道处理分数的方法如何通过名称直接访问两个实例变量 numerator 和 denominator 的情况。事实上,实例方法总
  • day1: Objective-C概述、面向对象编程、类和对象、实例变量操作

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,164
精华内容 3,265
关键字:

面向对象实例变量