类和对象_定义类2

详细研究如何去定义一个类。

1.  一个类由三个部分组成。这三个部分并不是全部必须的。

在编写类之前，要先设计类：数据(用成员变量来表示)，和对这些数据的操作(用成员方法来表示)。

class 类名{//1.成员变量//3.构造器(构造方法) -> 其中一个重要作用，是对成员变量进行初始化//2.成员方法 —> 用来操作本类中的成员变量/或者像一个普通的方法(函数)一样}

2.成员变量。

也叫"字段"。它的定义和一般变量是一样的。

成员变量也叫"实例变量"，如果不明确赋值的话，会自带一个默认的值。

成员变量：遵循标识符的命名规则；驼峰命名法，首字母小写：望文生义。

class C{byte byteVar;byte shortVar;int intVar;long longVar;float floatVar;double doubleVar;char charVar;boolean booleanVar;String string;}public class Demo{public static void main(String[] args){C c = new C();System.out.println(c.byteVar);System.out.println(c.shortVar);System.out.println(c.intVar);System.out.println(c.longVar);System.out.println(c.floatVar);System.out.println(c.doubleVar);System.out.println(c.charVar);System.out.println(c.booleanVar);System.out.println(c.string);}}

3.成员方法。

语法格式void |数据类型 方法名称(参数列表){//方法体}

3.1方法命名：遵循标识符的命名规则；驼峰命名法，首字母小写：望文生义。方法的命名：动词+名词。

3.2方法名称后面，必须紧跟一对小括号。小括号内，可以有参数(有1个或多个。如果有多个的话，称为参数列表，用逗号

     分隔)，也可以没有参数。

3.3方法命名前，要指定该方法返回数据类型。(既可以是原始数据类型，也可以是自定义数据类型，还可以是数组)。

     如果该方法的代码调用后，不要求有返回值，那么，必须用void关键字指明。

     如果该方法的代码调用后，有返回值，那么，在方法体内(花括号内)，必须要有"return 返回数据"语句，并且返回数据的类型，要和方法名前指定的数据类型保持一

     致。

3.4对方法的调用：通过方法名称(后跟小括号)的方式调用。

3.5方法声明中的参数，为局部变量。局部变量和成员变量的区别：

    局部变量的生命周期(变量的作用域)，仅限于从它声明开始，到所在方法结束。

3.6参数传递中的"值传递"和"引用传递"。

3.7当一个类中有多个同名的方法、但方法签名不同时，称为"方法重载"，又叫"动态方法调用"。

     方法签名 ->方法签名 = 方法名称 + 参数数量和类型/顺序。

//定义一个小计算器类class Calculate{//加法运算int add(int number1, int number2){//这里定义的参数称为"形参"int result = number1 + number2;return result;}//对两个整数值进行交换void swap(int number1, int number2){int temp;temp = number1;number1 = number2;number2 = temp;}void swap(int[] numbers){int temp;temp = number[0];number[0] = number[1];number[1] = temp;}}public class Demo{public static void main(String[] args){int a = 3, b = 5;Calculate cal = new Calculate();int addResult = cal.add(a, b);//这里传进去的a和b成称为"实参"System.out.println(addResult);System.out.println("交换方法调用前：a=" + a + ",b=" + b);//a = 3,b = 5cal.swap(a, b);System.out.println("交换方法调用后：a=" + a + ",b=" + b);//a = ?,b = ? -> 值传递int[] intArray = {3, 5};System.out.println("交换方法调用前：" + intArray[0] + "," + intArray[1]);cal.swap(intArray);System.out.println("交换方法调用后：" + intArray[0] + "," + intArray[1]);//a = ?,b = ? -> 引用传递}}

//需求：保存多个学生的信息。（使用成员方法） class Student{ //成员变量    String stuName;     //学号字段      int stuId;          //姓名字段      int stuAge;         //年龄字段  //成员方法//自我介绍void selfinfo(){System.out.println("我叫" + stuName + ",我的学号是" + stuId + ",我的年龄是" + stuAge);}}    public class Demo{      public static void main(String[] args){          //1.定义一个Student类型的数组，他只能存入Studnet类型的变量          Student[] stus = new Student[2];            //2.创建并保存第一个学生信息          Student stu01 = new Student();          stu01.stuName = "张三";          stu01.stuId =  111;          stu01.stuAge = 18;          stus[0] = stu01;            //3.创建并保存第二个学生信息          Student stu02 = new Student();          stu02.stuName = "李四";          stu02.stuId =  222;          stu02.stuAge = 19;          stus[1] = stu02;            //for-each遍历数组          for(Student stu : stus){              System.out.println("学号：" + stu.stuId + "    姓名：" + stu.stuName + "  年龄：" + stu.stuAge);          }            System.out.println("--------------------------------------");            //普通for循环          for(int i = 0;i < stus.length;i++){              Student stu = stus[i];              //System.out.println("学号：" + stu.stuId + "    姓名：" + stu.stuName + "  年龄：" + stu.stuAge); stu.selfinfo();//对对象中方法的调用        }    }}

3.8 可变参数：参数的数量是可变的。

      1)可变参数，必须是位于参数列表中的最后一个。

      2)可变数量：0、1或多个。

      3)可变数量，是作为数组进行处理的。

//定义一个小计算器类class Calculate{//加法运算int add(int... numbers){//使用可变参数int result = 0;for(int i=0;i<numbers.length;i++){result = result + numbers[i];}return result;}}public class Demo{public static void main(String[] args){Calculate cal = new Calculate();System.out.println(cal.add());System.out.println(cal.add(1));System.out.println(cal.add(1,1));System.out.println(cal.add(1,1,1));}}

4. 变量的作用域。

4.1 在一个类中，有三个地方可以定义变量(三种变量)：类的字段部分(成员变量)、方法的参数变量(局部变量)、方法内声明的变量(局部变量)。

4.2 如果局部变量和成员变量同名的情况下，局部变量屏蔽成员变量。

4.3  局部变量，它的作用范围，是从声明它的地方开始，到方法的结束。

4.4  成员变量定义的位置不关紧，它的作用域范围总是在整个内部类。

4.5  所以，好的做法是，尽可能的不要让局部变狼与成员变量同名。

class VarScope{int number = 0;//成员变量void write(){System.out.println(number);}void write(int number){//参数变量(局部变量)System.out.println(number);}void writeNumber(){System.out.println(number);int number = 3;//局部变量,它的作用范围,是从声明它的地方开始,到方法的结束。System.out.println(number);}}public class Demo{public static void main(String[] args){VarScope vs = new VarScope();vs.write();//?vs.write(5);//? -> 如果局部变量和成员变量同名的情况下，局部变量屏蔽成员变量vs.writeNumber();//? ?}}

5.  this关键字

但是，有的时候，局部变量又最好是和成员变量同名。

在局部变量屏蔽成员变量的情况下，如果想要绕开这种屏蔽，能访问到成员变量，需要使用this关键字。

6.  属性

实际上，属性不是字段。只有提供了get方法的字段，才称为属性。

//什么情况下，局部变量最好和成员变量同名class Student{//成员变量(字段)private String stuId;private String stuName;private int stuAge;//set方法：set开头，后跟字段的名字，首字母变成大写//这些setter、getter方法，称为"读写器"public void setStuId(String stuId){this.stuId = stuId;}//把"get"去掉后面首字母换成小写，叫做"属性"//有一个属性叫"stuId"public String getStuId(){return this.stuId;}public void setStuName(String stuName){this.stuName = stuName;}//有一个属性叫"stuName"public String getStuName(){return this.stuName;}public void setStuAge(int stuAge){if(stuAge<18)this.stuAge = 18;elsethis.stuAge = stuAge;}//有一个属性叫"stuAge"public int getStuAge(){return this.stuAge;}//有一种属性叫"angthing"public String getAnything(){return "anything";}}public class Demo{public static void main(String[] args){Student zhangsan = new Student();//zhangsan.StuId="112";//zhangsan.StuName="张三";//zhangsan.StuAge=18;zhangsan.setStuId("111");zhangsan.setStuName("张三");zhangsan.setStuAge(18);System.out.println(zhangsan.getStuId());System.out.println(zhangsan.getStuName());System.out.println(zhangsan.getStuAge());}}

7.  构造器

7.1  构造器，也叫构造方法。其名称必须和类名相同，后跟方法的小括号，再后跟方法体花括号。

7.2  构造方法也可以重载。

7.3  构造器的主要作用：对成员变量进行初始化、加载资源、……

7.4  构造器的使用：在创建类的实例对象时，使用new运行符，调用构造器，来创建实例，申请空间。

      通过构造实例对象时，传递的构造器参数，来对成员变量进行初始化。

class Student{//成员变量private String stuId;private String stuName;private int stuAge;//构造器(构造方法)Student(){System.out.println("无参构造器");}Student(String stuId){this.stuId = stuId;System.out.println("1个参数构造器");}Student(String stuId, String stuName){this.stuId = stuId;this.stuName = stuName;System.out.println("2个参数构造器");}Student(String stuId, String stuName, int stuAge){this.stuId = stuId;this.stuName = stuName;this.stuAge = stuAge;System.out.println("3个参数构造器");}//读写方法：get和set//...}public class Demo{public static void main(String[] args){Student stu = new Student(); Student stu01 = new Student("111");Student stu02 = new Student("112","张三");Student stu03 = new Student("113","李四",18);}}

7.5  通过this关键字调用同一对象中的其他构造器。

class Student{//成员变量private String stuId;private String stuName;private int stuAge;//构造器(构造方法)Student(){System.out.println("无参构造器");}Student(String stuId){System.out.println(this.stuId);this.stuId = stuId;System.out.println("1个参数构造器");System.out.println(this.stuId);}Student(String stuId, String stuName){this(stuId);//调用当前对象中带一个参数的构造器this.stuName = stuName;System.out.println("2个参数构造器");}Student(String stuId, String stuName, int stuAge){this(stuId,stuName);if(stuAge < 18)this.stuAge = 18;elsethis.stuAge = stuAge;System.out.println("3个参数构造器");}//读写方法：get和set//...}public class Demo{public static void main(String[] args){Student stu = new Student("111","三");//Student stu01 = new Student("111");//Student stu02 = new Student("112","张三");//Student stu03 = new Student("113","李四",18);}}

7.6  如果在定义类时，不明确制定一个构造器，那么编译器在编译时，会自动的添加一个空的默认的构造器

      但是，一旦你指定了一个构造器，那么，编译器就不会再插入默认的构造器了。