2019-7-2 [JavaSE] 递归 封装 重载 构造 与普通方法和访问器的区别 构造块 成员变量初始化 构造器和访问器

1.递归

递归：允许程序调用自身的一种方式。

特点:

1.方法；
2.调用自身；
3.出口。 （结束的条件）

实例：n的阶乘

public int fac(int n) {
		if(n == 1) 
			return 1;
		return n * fac(n-1);
	}

2.封装

封装:隐藏了实现细节，对外提供公共的访问方式。

好处：

1.安全性；2.用户只能用我提供的访问方式来访问；3.方法中可以使用流程控制语句来控制赋值的准确性。

class Person{
	//私有的
	private int age;
	//setter访问器 写
	public void setAge(int age) {
		if(age >= 18 && age <= 65) {
			this.age = age;
		}else {
			age = 0;
		}
	}
	//getter 访问器 读
	public int getAge() {
		return age;//this.age
	}
}

3.重载

方法重载：

通常 同一个类，

方法名相同，
参数列表不同（个数，类型，顺序），
与返回值无关。

作用：

方便记忆。

public void f() {
		System.out.println("f");
	}
	public void f(byte n) {
		System.out.println("byte");//
	}
	public void f(short n) {
		System.out.println("short");
	}
	public void f(int n) {
		System.out.println("int");
	}
	public void f(int ...n) {// f (111)
		System.out.println("int...");
	}
	public void f(int [] n) {
			System.out.println("int[]");
	}
	
	 public void f(String ...n){
	 }
	 
	public void f(long n) {
		System.out.println("long");
	}
	public void f(char n) {
		System.out.println("char");
	}
	public void f(float n) {
		System.out.println("float");
	}
	public void f(double n) {
		System.out.println("double");
	}
	public void f(int n1, double n2) {
		System.out.println("intdouble");
	}
	public void f(double n3, int n2) {
		System.out.println("doubleint");
	}

4.构造

语法注意：

 1. 构造名与类名必须一致；
 2.不要定义返回值类型。

作用:

初始化对象。

1.默认构造：
当类中没有显示定义任何的构造器，那么编译器会隐式的自动生成一个默认构造器。（这个构造无参）
只要在代码中 显示定义了构造器，默认构造就不存在了。
2.无参构造
3.带参数

/**
 * 员工类
 */
class Employee{
	private String name;
	private String sex;
	private int age;
	//无参构造
	Employee(){
		this.name = "郭靖";
		this.sex = "男";
		this.age = 22;
	}
	public Employee(String name,String sex,int age){
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	/*
	 默认构造方法
	 Employee(){
	   //super();//隐含的功能
	   }
	 */
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String show() {
		return name + "," + sex + "," + age;
	}
}
/**
 * 测试员工类
 */
public class TestEmployee {

	public static void main(String[] args) {
		//                      调用了构造方法（构造器）
		Employee guojing = new Employee("郭靖","男",22);
		System.out.println(guojing.show());//
		Employee yangkang = new Employee("杨康","男",21);
		System.out.println(yangkang.show());
		Employee huangrong = new Employee();		
	}
}

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

1.功能：

 构造器：初始化对象；
 普通： 特定的功能。

2.调用：

  构造器：只有 new创建对象时  调用；
  普通:    在 使用时 ，创建对象调用。

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

1.构造器 创建完对象 我自己赋值 就有数据；
访问器 ：对象创建完成后使用的是系统的默认值。
2.构造器： 创建对象时 可以一次性的给所有成员变量赋值；
访问器： 创建对象后，逐个访问 赋值。
3.对象创建之后，想修改成员变量的值 ，需要用 setter访问器。
4.对象创建之后，想获得成员变量的值，需要用 getter访问器。

构造块：

语法：

class 类{
{
//构造块
作用:初始化对象。
执行顺序上：先执行 构造块，后执行构造器。
}
}

实例：

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 = "匿名";
//		this.address = "内蒙古";
	}
	public Role(String job) {
		this.job = job;
//		this.address = "内蒙古";
	}
	public Role(String name,String job,String sex) {
		this.name = name;
		this.job = job;
		this.sex = sex;
//		this.address = "内蒙古";
	}
	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;
//		this.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("郭靖","男",22,"大侠","浙江");
		System.out.println(guojing.show());
	}
}

5.成员变量初始化

class Demo{
//默认初始化
	private int n = 11;
//声明处初始化
	{
		n = 22;
	}
//构造块初始化
	public Demo() {
		n = 33;
	}
//构造器初始化
	public int getN() {
		return this.n;
	}
}
public class TestInitial {

	public static void main(String[] args) {
		Demo demo = new Demo();
		System.out.println(demo.getN());
	}
}

6.编写：封装练习

编写一个类Book:

属性：名称（title）、页数（pageNum），

要求：其中页数不能少于200页，否则输出错误信息，并赋予默认值200；

访问器：为各属性设置赋值和取值方法；

方法:show，用来在控制台输出每本教材的名称和页数；

编写测试类TestBook1进行测试：为Book对象的属性赋予初始值，

并调用Book对象的show方法，看看输出是否正确。

/**
 * 练习：
 * 封装、构造
 * */
class Book{
	private String title;
	private int pageNum;
	private String type;
	
	//访问器
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public int getPageNum() {
		return pageNum;
	}
	public void setPageNum(int pageNum) {
		if(pageNum >= 200) {
			this.pageNum = pageNum;
		}else {
			System.out.println("赋值错误，必须不少于200页");
			this.pageNum = 200;
		}
	}
	public String show() {
		return title + "\t" + pageNum;
	}
	
}
public class TestBook_exam {

	public static void main(String[] args) {
		Book book = new Book("数据结构",600);
//		book.setTitle("计算机基础");
//		book.setPageNum(500);
		System.out.println(book.getTitle() + "\t" + book.getPageNum());
		System.out.println(book.show());
	}

}

7.编写：重载练习

编写Addition类，该类中应包含一组实现两数相加运算的重载方法。

实现加法运算的方法，应接受两个参数（即加数和被加数），

方法将两个参数进行加法运算后，返回相加结果。

考虑可能针对不同的数据类型进行计算，

重载一组方法，包括整型、长整型、浮点型、双精度浮点型、还有字符串。

在main方法中创建Addition类的实例，分别调用重载方法测试其效果。

/**
 * 练习：
 * 方法重载
 * 重载一组加法运算
 * */
class Addition{
	public int add(int n1, int n2) {
		return n1 + n2;
	}
	public long add(long n1,long n2) {
		return n1 + n2;
	}
	public float add(float n1,float n2) {
		return n1 + n2;
	}
	public double add(double n1,double n2) {
		return n1 + n2;
	}
	public String add(String s1, String s2) {
		return s1 + s2;
	}
	public int add(String s1,String s2) {
		return Integer.parseInt(s1+s2);
	}
}
public class TestOverload_exam {
	public static void main(String[] args) {
	}
}

8.编写：构造练习

继续编写Book类：

属性：名称（title）、页数（pageNum）；

方法： show，用来在控制台输出每本教材的名称和页数。

带参构造方法：用来完成对象的初始化工作，并在构造方法中完成对页数的最小值限制

（页数不能少于200页，否则输出错误信息，并赋予默认值200）

编写测试类TestBook2进行测试：初始化一个Book对象，

并调用该Book对象的show方法，看看输出是否正确

/**
 * 练习：
 * 封装、构造
 * */
class Book{
	private String title;
	private int pageNum;
	private String type;
	//构造器：给所有属性赋值
	public Book(String title, int pageNum) {
		this.title = title;
		if(pageNum >= 200) {
			this.pageNum = pageNum;
		}else {
			System.out.println("赋值页数不能少于200页");
			this.pageNum = 200;
		}
		this.type = "计算机";
	}
	public Book(String title,int pageNum,String type) {
		this.title = title;
		if(pageNum >= 200) {
			this.pageNum = pageNum;
		}else {
			System.out.println("赋值页数不能少于200页");
			this.pageNum = 200;
		}
		this.type = type;
	}
	//访问器
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public int getPageNum() {
		return pageNum;
	}
	public void setPageNum(int pageNum) {
		if(pageNum >= 200) {
			this.pageNum = pageNum;
		}else {
			System.out.println("赋值错误，必须不少于200页");
			this.pageNum = 200;
		}
	}
	public String show() {
		return title + "\t" + pageNum;
	}	
}
public class TestBook_exam {

	public static void main(String[] args) {
		Book book = new Book("数据结构",600);
//		book.setTitle("计算机基础");
//		book.setPageNum(500);
		System.out.println(book.getTitle() + "\t" + book.getPageNum());
		System.out.println(book.show());
	}
}

9.编写：构造重载练习book

继续编写Book类：

属性：名称（title）、页数（pageNum）、种类（type）

方法：show，用来在控制台输出每本教材的名称、页数、种类

两个带参构造方法：

第一个构造方法中，设置教材种类为“计算机”（固定），其余属性的值由参数给定；

第二个构造方法中，所有属性的值都由参数给定

编写测试类TestBook3进行测试：

分别以两种方式完成对两个Book对象的初始化工作，

并分别调用它们的show方法，看看输出是否正确

/**
 * 练习：
 * 封装、构造
 * */
class Book{
	private String title;
	private int pageNum;
	private String type;
	//构造器：给所有属性赋值
	public Book(String title, int pageNum) {
		this.title = title;
		if(pageNum >= 200) {
			this.pageNum = pageNum;
		}else {
			System.out.println("赋值页数不能少于200页");
			this.pageNum = 200;
		}
		this.type = "计算机";
	}
	public Book(String title,int pageNum,String type) {
		this.title = title;
		if(pageNum >= 200) {
			this.pageNum = pageNum;
		}else {
			System.out.println("赋值页数不能少于200页");
			this.pageNum = 200;
		}
		this.type = type;
	}
	//访问器
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public int getPageNum() {
		return pageNum;
	}
	public void setPageNum(int pageNum) {
		if(pageNum >= 200) {
			this.pageNum = pageNum;
		}else {
			System.out.println("赋值错误，必须不少于200页");
			this.pageNum = 200;
		}
	}
	public String show() {
		return title + "\t" + pageNum;
	}	
}
public class TestBook_exam {

	public static void main(String[] args) {
		Book book = new Book("数据结构",600);
//		book.setTitle("计算机基础");
//		book.setPageNum(500);
		System.out.println(book.getTitle() + "\t" + book.getPageNum());
		System.out.println(book.show());
	}
}

10.编写：构造重载练习Flour

/**
 * 练习：构造重载
 * 创建一碗面，酸辣面，二两，带汤的
 * */
class Flour{
	private String type;
	private int weight;
	private boolean soup;
	public Flour() {
		this.type = "酸辣面";
		this.weight = 2;
		this.soup = true;
	}
	public Flour(String type, int weight) {
		this.type = type;
		this.weight = weight;
		this.soup = true;
	}
	public Flour(String type, int weight, boolean soup) {
		this.type = type;
		this.weight = weight;
		this.soup = soup;
	}
	public void check() {
		String strSoup;
		if(this.soup ) {
			strSoup = "带汤的";
		}else {
			strSoup = "不带汤的";
		}
		System.out.println(type + "," + weight+"两," + strSoup);
	}
}
public class TestFlour_exam {

	public static void main(String[] args) {
		Flour f1 = new Flour("酸辣面", 2, true);
		Flour f2 = new Flour("酸辣面", 2);
		Flour f3 = new Flour();
		f1.check();
		f2.check();
		f3.check()；
	}
}
//1.5-------------------------------
class Flour{
	private String type;
	private int weight;
	private boolean soup;
	public Flour (String type,int weight,boolean soup) {
		this.type = type;
		this.weight = weight;
		this.soup =soup;
	}
	public Flour (String type,int weight) {
		this.type = type;
		this.weight = weight;
		this.soup = true;
	}
	public Flour () {
		this.type = "酸辣面";
		this.weight = 2;
		this.soup = true;
	}
	public String check() {
		String ssoup;
		if (this.soup) {
			ssoup = "带汤的";
		} else {
			ssoup = "不带汤的";
		}
		return type + "\t" + weight + "\t" + ssoup;
	}	
}

public class Demo5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Flour tang = new Flour();
		System.out.println(tang.check());
		Flour tang2 = new Flour("酸辣面2", 3);
		System.out.println(tang2.check());
		Flour tang3 = new Flour("酸辣面3", 4, false);
		System.out.println(tang3.check());				
	}
}

11.利用快捷键创建封装的构造器和访问器

使用方法如代码所示：

class Student{
	private String name;
	private int score;
	private double height;
	
//快捷键alt + shift + s  生成 构造器
//选择不带参数的 Generate Construction from superclass
//生成 不带参数的构造器 ↓
	public Student() {
	}

//快捷键alt + shift + s  生成 构造器
//选择带参数的 Generate Construction using fields
//生成 带参数的构造器 ↓
	public Student(String name, int score, double height) {
		this.name = name;
		this.score = score;
		this.height = height;
	}
//快捷键alt + shift + s  生成 访问器
//选择 Generate Getter and Setters
//生成 get/set访问器 ↓
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	public double getHeight() {
		return height;
	}
	public void setHeight(double height) {
		this.height = height;
	}
//使用show展示所有的访问信息
	public String show() {
		return name + "," + score + "," + height;
	}
}

12.注意

1.在调用不同的构造器时通过不同的参数列表来区分。例：TestRole
2.在调用顺序上：先执行构造块再执行构造器。
3.构造块在存储里先被放在构造器里，然后构造块被释放，构造块会先被读取，所以构造块先被执行
4.构造块的作用：解决多个调用时程序冗余的问题
5.允许程序调用自身的一种方式就是递归
6.好递归的特点：它是一种方法。它调用自身。它拥有结束的出口。
7.当一个问题比较复杂，用for循环不好实现时，使用递归比较方便
8.递归每进行一次都会开辟一个新空间，占用空间大。