Java

Java

---

******个人学习Java总结（4）******

---

一、循环控制（跳转）语句关键字【break，continue，return】

---

1、循环控制（跳转）语句在Java中有break、continue和return三个关键字。如：图1-1，循环控制语句关键字及其作用图。

图1-1，循环控制语句关键字及其作用图

2、在Java中有break、continue和return三个关键字具体实现。

public static void main(String[] args) {
		/*
		 * 	(1)break
		 * 	     循环第 1 次   	
		 *	     循环第 2 次   	
		 *	     i=3时，通过break跳出当前循环！
		 */
		for (int i = 1; i <= 5; i++) {
			if(i == 3) {
				System.out.println("i=3时，通过break跳出当前循环！");
				break;//结束当前循环，跳出当前循环体
			}
			System.out.printf("循环第 %d 次   \t\n",i);
		}
		
		/*
		 * 	(2)continue
		 * 	      循环第 1 次   	
		 *	      循环第 2 次   	
		 *	      i=3时，通过continue跳出当前循环，直接进入下一次循环！
		 *	      循环第 4 次   	
		 *	      循环第 5 次   
		 */
		int i = 1;
		while(i <= 5) {
			if(i == 3) {
				System.out.println("i=3时，通过continue跳出当前循环，直接进入下一次循环！");
				i++;
				continue;//跳出当前循环，进入下一次循环
			}
			System.out.printf("循环第 %d 次   \t\n",i);
			i++;
		}
		
		/*
		 * 	(3)return
		 * 	      构建一个测试return的方法：   testReturn(int n)
		 * 	      循环第 1 次   	
		 *	      循环第 2 次   	
		 *	      i=3时，通过return结束该测试方法！（不会继续打印输出，循环第 4 次 和循环第 5 次）
		 */
		testReturn(5);//测试return的方法	
	}
	/**
	*	 构建一个测试return的方法：   testReturn(int n)
	*/
	public static void testReturn(int n) {
		int j = 1;
		do {
			if(j == 3) {
				System.out.println("i=3时，通过return结束该测试方法！");
				j++;
				return;//结束当前整个方法
			}
			System.out.printf("循环第 %d 次   \t\n",j);
			j++;
		}while(j <= n);
	}

---

二、Java中的方法（method）和构造方法（Constructor）

---

1、方法（method）和构造方法（Constructor）

1、方法（method）和构造方法（Constructor）概念和作用。其中，方法也叫做函数，构造方法也叫做构造函数或者构造器。如：图2-1-1，方法和构造方法概念与作用图。

图2-1-1，方法和构造方法概念与作用图

2、方法（method）和构造方法（Constructor）注意事项

2-1、方法（method）注意事项

1、方法（method）的语法结构。

	/*
	 * 	方法的语法结构：
	 * 		修饰符   返回值类型   方法名（形参1, 形参2, ...） {
	 *			具体功能的代码块内容;
	 *		}
	 */

2、方法（method）的调用。
（1）被调用的方法（被调用方）与调用该方法（调用方）处于同一各类中，则可直接调用。即：方法名(实参1, 实参2, …);
（2）被调用方与调用方不处于同一个类中，跨类调用时要去看方法的修饰符来确定的是否可以调用和如何调用。如：
  ①若方法被static修饰（静态方法），则调用方式为：方法所在类名.方法名(实参1, 实参2, …);即可。
  ②若方法未被static修饰（非静态方法），则调用方式为：方法所在类创建的对象.方法名(实参1, 实参2, …);即可。

3、方法（method）的调用注意事项。
（1）在被static修饰的方法（静态方法）中不能够直接去调用未被static修饰的其他方法（非静态方法）。
（2）在未被static修饰的其他方法（非静态方法）中可以调用其他静态方法。

public class Test {
	public static void main(String[] args) {
		// 2-(1)	被调用方与调用方处于同一个类
		showContent("被调用方与调用方处于同一个类的调用方式。");
		System.out.println("------------------------------------");//标记区分打印输出内容
		// 2-(2)-①	被调用方与调用方不处于同一个类，被调用方被static修饰的静态方法
		NewTest.showConten_A("被调用方与调用方不处于同一个类，被调用方被static修饰的静态方法。");
		System.out.println("------------------------------------");//标记区分打印输出内容
		// 2-(2)-②	被调用方与调用方不处于同一个类，被调用方未被static修饰的非静态方法
		new NewTest().showConten_B("被调用方与调用方不处于同一个类，被调用方未被static修饰的非静态方法。");
	}
	/**
	 * 	自定静态展示内容（content）的方法：showContent()
	 * @param content——传入方法的String类型的形参内容
	 * 
	 *	注意事项 3-（1）
	 * 	若showContent(String content)未被static修饰
	 *	public void showContent(String content) {
	 *		System.out.println("在Test类中，展示的内容是："+content);
	 *	}
	 *	则在被static修饰的主方法（main）中showContent(String content);
	 *	这样调用会报错：Cannot make a static reference to the non-static method showContent(String) from the type Test
	 */
	public static void showContent(String content) {
		System.out.println("在Test类中，展示的内容是："+content);
	}	
}
class NewTest{
	/**
	 * 	自定静态展示内容（content）的方法：showConten_A()
	 * @param content
	 */
	public static void showConten_A(String content) {
		System.out.println("在NewTest类中（静态），展示的内容是："+content);
	}
	/**
	 *	 自定非静态展示内容（content）的方法：showConten_B()
	 * @param content
	 * 
	 *	注意事项 3-（2）
	 * 	在NewTest类中showContent_A(String content)被static修饰
	 *	public static void showContent_A(String content) {
	 *		System.out.println("在NewTest类中（静态），展示的内容是："+content);
	 *	}
	 *	则在未被static修饰的方法（showConten_B）中可以showContent(String content);
	 *	不会报错
	 */
	public void showConten_B(String content) {
		System.out.println("在NewTest类中（非静态），展示的内容是："+content);
		System.out.println("************************************");//标记区分打印输出内容
		showContent_A("未被static修饰的其他方法（非静态方法）中可以调用其他静态方法。");
	}
}

2-2、构造方法（Constructor）注意事项

1、构造方法（Constructor）语法结构。

	/*
	 *	(1)无参构造方法的语法结构（使用在对象需赋值的成员变量多时）：
	 * 		修饰符   类名（） {
	 *			
	 *		}
	 *	
	 * 	(2)有参构造方法的语法结构（使用在对象需赋值的成员变量少时）：
	 * 		修饰符   类名（成员变量形参1，成员变量形参2，...） {
	 *			该类名的类中成员变量赋值;
	 *		}
	 */

2、构造方法（Constructor）的调用和匿名对象。
（1）匿名对象：只是通过new的方式创建的对象，没有用一个变量去承接和保存该对象。（简单说：就是没有名字的对象。）
  【从内存角度去看，匿名对象只是在堆中开辟了空间和分配了地址，并没有在栈中用某个变量将对象在堆中分配的地址保存起来，形成指向引用。】
（2）跨类调用构造方法的方式（实例化）为：
  ①若无参构造方法，则调用方式为：类名 对象 = new 类名();
    或者 new 类名();【匿名对象】即可。
  ②若有参构造方法且直接给成员变量赋值，则调用方式为：类名 对象 = new 类名(成员变量形参1, 成员变量形参1, …);
    或者 new 类名(成员变量形参1, 成员变量形参1, …);【匿名对象】即可。
  ③若类之间存在继承关系，则可以使用多态对所继承的类中构造方法进行调用。【PS：在后续多态中会有具体调用方式。】
（3）跨类给无参构造方法所处类中的成员变量赋值方式为：
  ①若成员变量被private修饰（私有化），则赋值方式为：先实例化，再对象.成员变量
    或者 new 类名().成员变量;【匿名对象】即可。
  ②若成员未变量被private修饰（私有化），需在构造方法所处类中给成员变量创建对应的Setters和Gettters方法，则赋值方式为：先实例化，再对象.setXXX();或者对象.getXXX();即可。

3、构造方法（Constructor）的调用注意事项和匿名对象的相关。
（1）构造方法（Constructor）的调用注意事项。
  ①构造方法通过new实例化，就会在堆中创建对象，最好不要给用给已创建并赋值的对象在进行赋值。
  ②构造方法不能被 static、final、synchronized、abstract等非访问性质的修饰符修饰，不能有返回值类型（包含void）。
  ③无参构造方法是隐式默认的，可以不写出来，但是一旦存在有参构造方法（显示构造方法）时，隐藏默认构造方法就会没有。【推荐：创建构造方法时无参与有参一起写出来。】
  ④构造方法名要与所处类的类名一致。
  ⑤构造方法不能被继承。
（2）匿名对象的相关。
  ①匿名对象是不能给该对象对应的类中成员变量进行赋值的。
  ②匿名对象可用于一次性的调用某方法和作为一次性参数进行传递使用（一次性情况使用）。
  ③匿名对象的使用可以节约资源开销，提升性能。
   【由于Java中垃圾回收机制（GC机制）会不定时的回收垃圾，这里的垃圾是指失去引用的对象。】

public class TestConstructor {
	public static void main(String[] args) {
		// 2-(2) 与 2-(3) 
		System.out.println("无参构造方法调用与赋值：");
		Constructor constructor1 = new Constructor();
		constructor1.number = 1;
		constructor1.setStr("非默认1");
		System.out.println("number："+constructor1.number+"	str："+constructor1.getStr());
		System.out.println("无参构造方法调用【匿名对象】：");
		System.out.println("number："+new Constructor().number+"	str："+new Constructor().getStr());
		System.out.println("有参构造方法调用与赋值：");
		Constructor constructor2 = new Constructor(2,"非默认2");
		System.out.println("number："+constructor2.number+"	str："+constructor2.getStr());
		// 3-(2)- ①
		System.out.println("匿名对象是不能给该对象对应的类中成员变量进行赋值的：");
		new Constructor().number = 3;
		new Constructor().setStr("非默认3");
		new Constructor().showContent();
		/*
		 * 	运行结果：
		 * 
		 *	无参构造方法调用与赋值：
		 *	number：1	str：非默认1
		 * 	无参构造方法调用【匿名对象】：
		 *	number：0	str：默认
		 *	有参构造方法调用与赋值：
		 *	number：2	str：非默认2
		 *	匿名对象是不能给该对象对应的类中成员变量进行赋值的：
		 *	number：0	str：默认
		 * 
		 */
	}
}
class Constructor{
	/*
	 * 	定义一个公有成员变量number和一个私有成员变量str
	 */
	public int number = 0;
	private String str = "默认";
	/**
	 * 	无参构造方法
	 */
	public Constructor() {}
	/**
	 * 	有参构造方法
	 * @param number
	 * @param str
	 */
	public Constructor(int number, String str) {
		this.number = number;
		this.str = str;
		/*
		 * 	上面两句也可写成：
		 * 		number = number; ——最好传入形参名不要与成员变量名相同
		 * 		setStr(str);
		 */
	}
	/**
	 * 	私有成员变量str的获取方法：getStr()
	 * @return
	 */
	public String getStr() {
		return str;
	}
	/**
	 * 	私有成员变量str的写入方法：setStr(String str)
	 * @param str
	 */
	public void setStr(String str) {
		this.str = str;
	}
	/**
	 * 	展示Constructor类中成员变量值是否改变的方法：showContent()
	 */
	public void showContent() {
		System.out.println("number："+this.number+"	str："+this.str);
		/*
		 * 	上面一句也可写成：
		 * 		System.out.println("number："+this.number+"	str："+getStr());
		 */
	}
}

---

三、方法重载（Overload）和方法重写（Override）

---

1、方法（函数）签名

1、方法（函数）签名是由方法名和参数列表组成，其中参数列表包括形参类型、形参数量和形参顺序三部分。
（1）方法签名与修饰符和返回值无关。
（2）方法签名与异常无关。

2、方法重载（Overload）

1、方法重载是指在同一个类里面，多个方法的方法名相同，参数列表不同。（返回值可相同也可不同。）
（1）每一个重载的方法都有该方法独有的方法标签（该处主要是指参数列表都不相同）。
（2）方法重载的优点在写程序时可以减少命名冲突，减少记忆量，且常在构造方法中常使用。

public class Test {
	public static void main(String[] args) {
		/*
		 *	3-1 与 3-2
		 *	构造方法的重载，请参阅构造方法处代码演示
		 *	运行结果：
		 *
		 *	重载	
		 *	----------------------------------
		 *	重载	重载1
		 *	----------------------------------
		 *	重载	重载1	重载2
		 *	----------------------------------
		 *	重载	重载1	重载2	重载3
 		 */
		NewClass test = new NewClass();
		test.showContent();
		System.out.println("----------------------------------");//标记区分打印输出内容
		test.showContent("重载1");
		System.out.println("----------------------------------");//标记区分打印输出内容
		System.out.println(test.showContent("重载1", "重载2"));
		System.out.println("----------------------------------");//标记区分打印输出内容
		System.out.println(test.showContent("重载1", "重载2",3));
	}
}
class NewClass{
	/**
	 * 	无返回值展示方法重载内容：showContent()
	 */
	public void showContent() {
		System.out.println("重载	");
	}
	/**
	 *	无返回值 展示方法重载内容：showContent(String str1)
	 * @param str1
	 */
	public void showContent(String str1) {
		System.out.println("重载	"+str1	);
	}
	/**
	 *	 有返回值 展示方法重载内容：showContent(String str1,String str2)
	 * @param str1
	 * @param str2
	 * @return
	 */
	public String showContent(String str1,String str2) {
		return "重载	"+str1+"	"+str2;
	}
	/**
	 *	有返回值 展示方法重载内容：showContent(String str1,String str2,int num)
	 * @param str1
	 * @param str2
	 * @param num
	 * @return
	 */
	public String showContent(String str1,String str2,int num) {
		return "重载	"+str1+"	"+str2+"	"+"重载"+num;
	}	
}

3、方法重写（Override）

1、方法重写或者覆盖是指在类之间存在继承关系，子类对父类允许访问的方法的实现过程重新编写（父类方法的实现无法满足子类需求时就需要子类对父类的方法进行重写。）
  方法重写时注意：
    （1）子类方法必须与父类方法的方法签名（方法名和参数列表）完全相同。
    （2）子类方法访问权限大于或等于父类方法的访问权限。
    （3）子类方法的返回值类型小于或等于父类方法的返回值类型。
    （4）子类方法的异常（Exception）类型小于或等于父类方法的异常类型。（重写的方法抛出的强制性异常是受被重写方法限制的。）
    （5）父类中被static、private和final修饰的方法不能被子类进行重写。
    （6）构造方法不能被重写。
    （7）重写方法的检验可以通过使用@Override标签，若重写出错则会报错，反之则不会报错。

public class Test {
	public static void main(String[] args) {
		/*
		 * 	运行结果：
		 *		展示内容方法所在类为：父类
		 *		----------------------------------
		 *		展示内容方法所在类为：子类
		 *		子类中完成重写父类方法
		 */
		FatherClass father = new FatherClass();
		father.showClassName();
		System.out.println("----------------------------------");//标记区分打印输出内容
		SonClass son = new SonClass();
		son.showClassName();
	}
}
/**
 * 	定义的父类FatherClass
 * @author
 *
 */
class FatherClass {
	//	私有成员变量：所在类的类名
	private String className = "父类";
	/**
	 * 	私有成员变量className的获取方法：getClassName()
	 * @return
	 */
	public String getClassName() {
		return className;
	}
	/**
	 * 	私有成员变量className的写入方法：setClassName(String className)
	 * @param className
	 */
	public void setClassName(String className) {
		this.className = className;
	}
	/**
	 * 	父类中无返回值展示所处类的类名：showClassName()
	 */
	public void showClassName() {
		System.out.println("展示内容方法所在类为："+this.className);
	}
}
/**
 * 	定义的子类SonClass，继承（extends）父类FatherClass
 * @author
 *
 */
class SonClass extends FatherClass {
	@Override  // 用于重写检验
	public void showClassName() {
		super.setClassName("子类");
		super.showClassName();
		/*
		 * 	(1)	上面两句的super可用this替换
		 *  (2)	重写方法中可以调用其他方法
		 */
		finishOverride();
	}
	public void finishOverride() {
		System.out.println("子类中完成重写父类方法");
	}
}

4、方法重载和方法重写的区别

1、方法重载和方法重写的具体区别。如：图3-4-1，方法重载和方法重写对比图。

图3-4-1，方法重载和方法重写对比图

---