构造方法

1.构造方法的基本概念

  1. class 类名{
  2.     类名(形参列表){
  3.         构造方法体;
  4.     }
  5. }
  6. class Person{
  7.     Person(){ //Person类中的构造方法}
  8. }
  1. //编程实现Person 的定义
  2. public class Person{
  3.     String name; //name成员变量
  4.     int age;    //age成员变量
  5.     //自定义构造方法
  6.     Person(){
  7.         System.out.println("我就是自定义的构造方法")
  8.     }
  9.     void show(){
  10.         System.out.println(name+","+age);
  11.     }
  12.     public static void main(String[] args){
  13.         Person p=new Person();
  14.         p.show(); //null 0;
  15.     }
  16. }
  17. -----------------------------
  18. ● 构造方法与类名完全相同并且没有返回值类型,连void都不许有
  19. 默认构造方法
  20. ● 当一个类中没有定义任何构造方法时,编译器会自动添加一个无参空构造方法,叫做默认(缺省)构造方法,如Person(){}
  21. ● 若类中出现了构造方法,则编译器不在提供任何形式的构造方法.
  22. ● 使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作
  23. 例如:编程实现Point类的定义并且Point类添加构造方法
  24.         Point()默认创建原点对象
  25.         Point()根据参数创建点对象
  26. public class Point{
  27.     int x;//用于描述横坐标的成员变量
  28.     int y;//纵坐标
  29.     //自定义无参构造方法
  30.     Point(){}
  31.     Point(int i,int j){
  32.         x=i;
  33.         y=j;
  34.     }
  35.     void show(){
  36.         System.out.println(x+","+y);
  37.     }
  38.     publi static void main(String[] args){
  39.         Point p1=new Point();
  40.         p1.show();//0 0
  41.         Point p2=new Point(1,2);
  42.         p2.show(); //1 2
  43.     }
  44. }

重载

1.重载的概念和体现形式

  1. //编程实现方法重载主要形式的ceshi
  2. public class OverloadTest{
  3.     //自定义成员方法
  4.     void show(){
  5.         System.out.println("show");
  6.     }
  7.     void show(int i){//体现在方法参数的个数不同
  8.         System.out.println("show(int)");
  9.     }
  10.     void show(int i,double d){//体现在方法参数的个数不同
  11.         System.out.println("show(int,double )");
  12.     }
  13.     void show(int i,int d){//体现在方法参数的类型不同
  14.         System.out.println("show(int,int)");
  15.     }
  16.     void show(double i,int d){//体现在方法参数的顺序不同
  17.         System.out.println("show(double i,int d)");
  18.     }
  19.     /*
  20.     void show(double i,int d){//error 与参数变量名无关
  21.         System.out.println("show(double i,int d)");
  22.     }  
  23.     int show(double i,int d){//error 与返回值类型无关
  24.         System.out.println("show(double i,int d)");
  25.     } 
  26.     */  
  27.     public static void main(String[] args){
  28.         OverloadTest o1=new OverloadTest();
  29.         o1.show();//show
  30.         o1.show(66);//show(int)
  31.         o1.show(66,3.13)//show(int,double ),50
  32.         o1.show(66,510)//show(int,int)
  33.         o1.show(3.14,66)//show(double i,int d)
  34.     }
  35. }
  36. ------------------------------------------------------------------
  37. 方法重载的主要形式体现在:
  38.                         参数的个数不同 
  39.                         参数的类型不同 
  40.                         参数的顺序不同 
  41.                         与返回值类型和参数变量名无关,但是建议返回值类型最好相同
  42. 判断方法能否构成重载的核心:调用方法时能否加以区分

2.重载的使用

  1. //自定义成员方法实现年龄增长一岁的行为
  2. void grow(){age++;}
  3. //自定义成员方法实现年龄增长参数指定数值的行为
  4. void grow(int i){age+=i;}
  6. //调用
  7. Person p3 =new Person("张飞",30);
  8. p3.grow();//31
  9. p3.grow(2);//33
  10. p1.show()//33

3.重载的实际意义

方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种不同的版本,来实现各种不同的功能
如java.util.PrintStream类中的println方法
方法和封装 - 图1

this关键字

1.this的基本概念

  1. public class ThisTest{
  2.     //自定义构造方法
  3.     ThisTest(){
  4.     //代表当前正在构造的对象
  5.         System.out.println("构造方法:this="+this);
  6.     }
  7.     void show(){
  8.     //代表当前正在调用的对象
  9.         System.out.println("成员方法:this="+this);
  10.     }
  11.     public static void main(String[] args){
  12.         ThisTest tt=new ThisTest();
  13.         tt.show();
  14.          System.out.println("main方法中:tt="+tt);
  15.     }
  16. }
  17. ------------------------------------------------
  18. ● 若在构造方法中出现了this关键字,则代表当前正在构造的对象
  19. ● 若在成员方法中出现了this关键字,则代表当前正在调用的对象
  20. ● this关键字本质上就是当前类类型的引用变量

2.this关键字的基本原理

在构造方法中和成员方法中访问成员变量时,编译器会加上this.的前缀,而this.相当于汉语中”我的”,当不同的对象调用同一个方法时,由于调用方法的对象不同导致this关键字不同,从而this.方法访问的结果也就随之不同

3.this的使用方式

  • 当局部变量与成员变量名相同时,在方法体中会优先使用局部变量(就近原则),若希望使用成员变量,则需要在成员变量的前面加上this.的前缀,明确要求改变量是成员变量(重中之重)
  • this关键字除了可以通过this.的方式调用成员变量和成员方法之外,还可以作为方法的返回值(重点)

  • 在构造方法的第一行可以使用this()的方式来调用本类中的其他构造方法(了解)

    1. public class Boy{
    2.   String name;    
    3.   Boy(){
    4.   //调用本类中的有参构造方法
    5.       //this("无名");
    6.       System.out.println("无参构造方法");
    7.   }
    8.   Boy(String name){
    9.       //调用本类中的无参构造方法
    10.       this();
    11.       System.out.println("有参构造方法");
    12.       this.name=name;
    13.   }
    14.   void show(){
    15.       System.out.println("我的名字是:"+name);
    16.   }
    17.   public static void main(String[] args){
    18.       Boy b1=new Boy();
    19.       b1.show();//null
    21.       Boy b2=new Boy("张飞");
    22.       b2.show();//张飞
    23.   }
    24. }

    封装

    通常情况下可以再测试类给成员赋值一些合法但不合理的数值,无论是编译阶段还是运行阶段都不会报错或者给出提示,此时与现实生活不符
    为了避免上述错误的发生,就需要对成员变量进行密封包装处理,来隐藏成员变量的细节以及保证成员变量的合理性,该机制就叫做封装

    封装的实现流程

  1. 私有化成员变量,使用private关键字修饰
  2. 提供共有的get和set方法,并在方法体中进行合理的判断
  3. 在构造方法中调用set方法进行合理值的判断

private关键字修饰表示私有的含义,也就是该成员变量只能在当前类的内部使用

  1. //私有化成员变量,使用private关键字修饰
  2. private int id;
  3. private String name;
  4. //提供共有的get和set方法,并在方法体中进行合理的判断
  5. //使用public关键字修饰表示公有的含义,也就是该方法可以再任意位置使用
  6. public int getId(){
  7.     return id;
  8. }
  9. public void setId(int id){
  10.     if(id>0){
  11.         this.id=id;
  12.     }else{
  13.         System.out.println("ID不合法!");
  14.     }
  15. }
  16. public String getName(){
  17.     return name;
  18. }
  19. public void setName(String name){
  20.     this.name =name;
  21. }
  22. //在构造方法中调用set方法进行合理值的判断
  23. Student(int id,String name){
  24.     setId(id);
  25.     setName(name);
  26. }

总结

  1. 构造方法(重中之重)

语法格式 默认无参构造方法 实现成员变量的初始化

  1. 方法重载(重点)

概念 体现形式 实际意义

  1. this关键字(原理)

概念 当前的正在调用/引用的成员变量 原理 使用方式

  1. 递归(难点)

概念:方法调用自身 使用原则:使问题简单化不是复杂化

  1. 封装(重中之重)

概念:私有和公共 保证合理性 实现流程