##Javase 重要知识点总结 day07

##Javase 重要知识点总结 day07

关键词：递归 构造方法 重载
#一、递归
允许反复调用自身编程的一种方法。
特点：
1.它是一种方法
2.行为就是：方法自己调用自己
3.有出口： 就是结束循环的条件。
案例：

package day07;public class recrusion {
//  public void m(){
//    System.out.println("recrusion is great");
//  }
//  public void f(){
//    System.out.println("learn it step by step");
//    m();
//  }
//  //可以调用同类中的另一个自定义方法，不用new出一个对象，这是在主方法外面，f()方法的语句体中，可以调用m（）方法也可以调用它自己f()int count=0;public void f(){count++;if (count ==6)return;System.out.println("learn it step by step");f();
}public static void main(String[] args) {
//      // TODO Auto-generated method stub
//    for (int i=0;i<5;i++){
//      System.out.println("recrusion");
//    }recrusion re= new recrusion();re.f(); }
}

points：

1. 同类中,一个方法可以调用另一个自定义方法，不用new出一个对象，这是在主方法外面。如第一例子中11行，f()方法的语句体中，可以调用m（）方法也可以调用它自己f()

points：

2.递归一层一层调用，（f(n)调用f(n-1)，f(n-1)调用f（n-2）），执行到出口结束条件呢，然后一层一层return，一层一层返回。
3.使用for循环和递归的区别：
因为使用f()方法，在栈内存中需要占用一定内存，反复调用就需要在栈内存中方法区 产生很多 f()，栈内存进行运行处理。而for循环不需要占用这么多的内存空间，所以： 使用递归（应用在一般比较难的，不容易解决的场合），使用for和其他循环（一般应用在比较简单的场合）

#二、封装
封装： 隐藏类的 属性 和 实现细节，对外 提供公共的访问方式。//方法，也是一种封装，因为你看不到细节，只管调用就可以了。
封装好处：
1.提供了安全的访问；//因为你看不到，里面的具体实现细节，除了按照指定格式修改参数，其他你也改不了。
2.只能用 提供的公共访问方式访问；
3.访问器中 可以使用流程控制语句的。
//setAge访问器，可以设置一些流程控制语句，已经规范了你设置的参数大小，格式啊范围啊之类的
setAge和getAge访问器,相当于读和写，有些调用只需要你，只读（setAge 没有，只有getAge）就行了，具体看情况。

package day07;
class person {//私有的private int age;public void setAge(int age){//访问器  写if(age>18 && age<65){this.age=age;}else {System.out.println("您输入的年龄有误");age=0;}}public int getAge(){  //访问器  读 return age;}           
}
public class encapsulation {public static void main(String[] args) {// TODO Auto-generated method stubperson en=new person();en.setAge(24);System.out.Age());}
}

#三、重载

作用：调用一个方法（例如math.abs(),这个方法），就可以适用这么多类型的变量，Math.abs()可以将long /double /float类型的数据，变成他的绝对值。简单方便。
方法重载：
1.通常同一个类中；
2.方法名相同，参数列表不同（个数，类型，顺序）；
3.返回值不能作为区分的依据。
point:
那么多方法，编译器就根据参数列表中的参数（包括参数类型、参数数量、参数的先后顺序）进行识别、区分。
基本应用：

package day07;
class selfintroduction {//自我介绍public void show(){System.out.println("I i am new here");}public void show(int age){System.out.println("my age is "+age);}public void show (String name){System.out.println("my name is "+ name);}public void show (int age ,String name){System.out.println("自我介绍");}
}
public class methodreload {public static void main(String[] args) {// TODO Auto-generated method stubselfintroduction p = new selfintroduction ();p.show(25, "wyl");}
}

#四、构造

方法名 与 类名 相同。
作用:初始化对象（给成员变量进行赋值），[不用每次你都要进行setAge ，setName都要 重新进行设置]
每次new出一个对象，都会执行构造方法。
默认构造：类中没有显示定义构造，那么编译器 会 自动创建一个默认构造，访问权限 与 类相同，没有参数。
*** 只要类中 显示定义了构造，那么默认构造就不存在了。
示例：

/*** 这是一个员工类* @author Tom* @version 1.0*/
class Employee{/** 编译器自动创建的* 默认构造* Employee(){}*/ // 声明处 初始化
/*  private int no = 11;// 0private String name = "郭靖";// nullprivate int age = 18;// 0
*/  private int no ;// 0private String name ;// nullprivate int age ;// 0// getter.setter// 定义构造，无参
/*  public Employee(){ = 11;this.name = "郭靖";this.age = 18;}*/// 带参构造public Employee(int no,String name,int age){ = no;this.name = name ;this.age = age ;}public String show() {// 展示学员信息return no + "," + name + "," + age;}
}
public class TestEmployee {/** public TestEmployee(){}*/public static void main(String[] args) {// Employee guojing = new Employee(11,"郭靖",18);System.out.println(guojing.show());Employee yangkang = new Employee(22,"杨康",18);System.out.println(yangkang.show());}}

声明处初始化 与 构造器初始化的区别：

1. 声明处初始化只能赋一个值；
   构造器 是个特殊的方法 ，方法中 可以有 流程控制语句。
   2.声明处初始化 初始值 不能改变；
   构造器 有参数，可以通过传参 改变 属性值。

普通方法和构造方法的区别：

1. 构造用来 初始化对象 ；
   普通方法用来 执行 特定的 功能的。
2. 构造 只能new 创建对象时调用；
   普通方法 ，用对象 随时调用，不调用就永远不执行。

构造方法和访问器的区别：

1. 构造 对象创建后 所有的数据 都赋值完成；
   访问器：创建对象后 还是 默认值 ，需要逐个调用 setter访问器赋值。
   2.构造可以一次性 给 所有的成员变量赋值；
   访问器：逐个调用 setter访问器赋值。

2. 构造只能赋值 ；
   修改 需要 setter访问器；
   4.构造只能赋值；
   获得数据 只能用getter访问器。
   （就是说，setter、getter访问器和构造方法同时存在更好，可以利用构造方法的赋值便利性，以及setter、getter修改和获取相应的值）

package day07;
class WebUser{private int userId;private String userPwd;private String userEmail;
//  {this.userPwd="999999";
//  }//这是一个构造块，相当于，所有构造方法，在执行时，第一行都会插入这个代码 this.userPwd=userPwd//首先执行这个代码public WebUser(){this.userPwd="999999";}public WebUser(int userId,String userEmail){//在一个构造方法中，调用另一个构造方法（带参数的构造方法）
//      位置：必须写在构造器中；//必须写在第一行代码
//      
/*  this();//调用本类中构造器，调用的是无参构造* this（2333，"wuuuu"）;//调用本类中的构造器，调用的是有参数构造。系统会根据，括号（）里面的参数寻找* 相应的有参构造方法* 作用：就是减少构造方法中代码的重复。* * */this.userId=userId;this.userEmail=userEmail;}public WebUser(int userId,String userEmial,String userEmail){this.userEmail=userEmail;this.userId=userId;this.userPwd=userPwd;}public String show(){return userId+"t"+userPwd+"t"+userEmail;}}public class TestWebUser {public static void main(String[] args) {// TODO Auto-generated method stubWebUser user1=new WebUser(23444,"99999","12nxdw");System.out.println(user1.show());  }
}

points：

1. 在一个构造方法中，调用另一个构造方法（带参数的构造方法） ，使用this（有参数or无参数）；//有参数就调用有参数的构造方法**： this(参数)；，无参数就调用无参数的方法： this（）；。**
   位置：必须写在构造器中；
   必须写在第一行代码
   例如：
   /* this();//调用本类中构造器，调用的是无参构造

• this（2333，“wuuuu”）;//调用本类中的构造器，调用的是有参数构造。系统会根据，括号（）里面的参数寻找

• 相应的有参构造方法

• 作用：就是减少构造方法中代码的重复。
  /
  调用构造：
  class Role{
  private String name;
  private String sex;
  private int age;
  private String job;
  // private String address = “内蒙古”;// 声明处初始化
  private String address;
  /
  {
  // 构造块
  // 初始化对象
  this.address = “内蒙古”;

  }*/

  public Role() {
  this.name = “匿名”;

  }
  public Role(String job) {
  /* this语句 ，调用本类构造
  * 只能用于 构造方法
  * 用于 构造方法中的第一行代码处
  */
  this();
  this.job = job;

  }
  public Role(String name,String sex,String job) {
  this(name,sex,0,job,null);
  // this.name = name;
  // this.sex = sex;
  // this.job = job;

  }
  public Role(String name,String sex,int age,String job,String address) {
  this.name = name;
  this.sex = sex;
  this.age = age;
  this.job = job;
  this.address = address;
  }
  public String show() {
  return name + “,”+ sex + “,” + age + “,” + job + “,” + address;
  }
  }
  public class TestRole {

  public static void main(String[] args) {
  Role person = new Role();
  System.out.println(person.show());
  Role killer = new Role(“杀手”);
  System.out.println(killer.show());
  Role ouyangke = new Role(“欧阳克”, “男”, “白驼山少主”);
  System.out.println(ouyangke.show());
  Role guojing = new Role(“郭靖”, “男”, 18, “大侠”, “内蒙古”);
  System.out.println(guojing.show());

  }

}
this:
就代表了 本类（当前类）对象
调用本类的成员。

1. 区分 成员 变量 和 局部变量同名；
2. 调用本类构造
   this(）语句。
   变量赋值过程：