java.流程控制语句的嵌套

流程控制语句的嵌套

单个流程控制语句不能满足需求时，使用嵌套的形式完成流程更复杂形式的实现

public class LoopTest {
	public static void main(String[] args) {
		//使用*打印一个长方形
//		System.out.println("***************");
//		System.out.println("***************");
//		System.out.println("***************");
//		System.out.println("***************");
//		System.out.println("***************");
		
		//以循环嵌套的形式完成
		//1.打印一个*
		System.out.println("*");
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");
		//2.去除换行
		System.out.print("*");
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");
		//3.使用循环打印一行并换行
		for (int i = 1; i < 15; i++) {
			System.out.print("*");
		}
		System.out.println();
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");
		//4.重复多次
		for(int j=1;j<=5;j++){
			for (int i = 1; i < 15; i++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");
		
		
		//使用*打印一个三角形
//		System.out.println("*");
//		System.out.println("**");
//		System.out.println("***");
//		System.out.println("****");
//		System.out.println("*****");
		//打印长方形修改条件
		for(int j=1;j<=15;j++){
			for (int i = 1; i <=j; i++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");
		//循环嵌套执行流程
		//外层循环执行一次，内层循环执行一个周期
		 
		for(int i=1;i<=15;i++){
			System.out.print("*");
			if(i==1||i==3||i==6||i==10){
				System.out.println();
			}
		}
		
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");
		//九九乘法表
		for(int j=1;j<=9;j++){
			for (int i = 1; i <=j; i++) {
				System.out.print(i+"*"+j+"="+(i*j)+" ");
			}
			System.out.println();
		}
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");
		//打印三角形直角边在右下
		for(int j=5;j>=1;j--){
			for (int i = 1; i <=5; i++) {
					if(i>=j){
						System.out.print("*");
					}else{
						System.out.print(" ");
					}
			}
			System.out.println();
		}
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");
		for(int j=1;j<=5;j++){
			for(int k=1;k<=5-j;k++){
				System.out.print(" ");
			}
			for (int i = 1; i <=j; i++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("~~~~~~~~~~~~~~~~~~~~~");
	}
}

方法

简单的说：方法就是完成特定功能的代码块
在很多语言里面都有函数的定义
函数在Java中被称为方法
格式：
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
函数体;
return 返回值;
}

方法由 修饰符 返回值类型 方法名 （参数列表）{方法体} 五部分组成

public static void main(String[] args) {}
public static:修饰符，可以理解为方法的使用权限
void：返回值类型，方法执行后返回的数据类型，不能省略，如果方法没有返回值，则使用void
main：方法名，符合标识符命名规范的字符串，用于标识方法使程序在运行时可以根据方法名找到并执行相应方法
参数列表：用于声明保存方法运行时需要的变量值，可以有0~无穷个参数
方法体：方法执行时具体执行的代码块

方法的分类

按照有无返回值、参数列表分为4类

无返回值、无参数列表

public static void sum1(){
		System.out.println(3+2);
	}

方法体以直接输出语句为主，结果直接打印在控制台，不能保存

所有数据方法体执行每次相同

(相当于将方法写死，用于固定执行的方法)

有返回值、无参数列表

	public static int sum2(){
		 return 3+2;
	}

结果可以返回使用变量保存，但结果值固定

所有数据方法体执行每次相同

(相当于将方法写死，用于获取固定值的方法)

无返回值、有参数列表

	public static void sum3(int a, int b){
		System.out.println(a+b);
	}

结果直接输出，根据输入参数改变而改变

相对于以上两种更加灵活，但返回结果不能保存，不能继续使用

有返回值、有参数列表

public static int sum4(int a, int b) {
		return a + b;
	}

有返回值可以保存执行的结果进行使用，有参数可以是程序根据不同参数动态执行

方法的调用

方法的使用通过方法名（参数列表）的形式进行调用

没有明确返回值的函数调用：
其实就是void类型方法的调用
只能单独调用
有明确返回值的方法调用：
单独调用，没有意义
输出调用，有意义，但是不够好，因为我不一定非要把结果输出
赋值调用，推荐方式

注意事项

方法参数列表声明的变量不需要赋值（在方法声明阶段）

方法调用阶段将实际的数据进行赋值

参数列表在调用时必须一一赋值，但在方法执行时可以不使用

方法不调用不执行（main方法默认执行）

方法与方法是平级关系，不能嵌套定义（方法只能在类体中声明）

方法定义的时候参数列表的参数之间用逗号隔开

方法调用的时候不用在传递数据类型

如果方法有明确的返回值，一定要有return带回一个值

方法的重载

在同一个类中，方法名相同，参数列表不同，我们称之为发生了方法的重载，或两个方法互为重载

参数列表不同

1.参数个数不同

2.参数个数相同，数据类型不同

3.参数个数相同，数据类型不同（2个以上），顺序不同

public static void main(String[] args) {
		//方法重载的优点
		//方法的执行实际上是通过方法名与参数列表进行调用
		//在调用时根据方法名确定执行的方法
		//如果存在多个方法 方法名相同那么jvm会自动根据调用方法时传递的参数决定调用方法
		//自动根据参数类型决定调用方法如果不存在则报错
	}

	public static int add(int a, int b) {
		return a + b;
	}

	// 参数个数不同
	public static int add(int a, int b, int c) {
		return a + b + c;
	}

	// 参数类型不同
	public static double add(int a, double b, int c) {
		return a + b + c;
	}

	// 顺序不同
	public static double add(int a, int b, double c) {
		return a + b + c;
	}

总结：
1.方法的组成： 修饰符、返回值类型、方法名、参数列表、方法体

2.方法的概念：java面向对象封装特点的体现，减少了代码的冗余，提高代码复用性与安全性

3.方法的分类：按照返回值类型参数列表分为四类

4.方法的调用：直接调用（无返回值） 输出调用（有返回值） 赋值调用（有返回值）

5.方法的重载：在本类中，两个方法方法名相同参数列表不同，称之为方生了方法的重载，参数列表不同（个数不同，类型不同，顺序不同（两个以上不同类型变量顺序不同））

面向对象编程思想

java是世界上第一门完全面相对象编程的计算机语言

面相对象编程的思想：将客观世界中具体存在的事物称之为对象，作为程序执行的最小单元，调用对象方法执行相应功能完成相应需求

特点：

是一种更符合我们思想的一种编程思路

将复杂的事物简单化（交由不同的对象进行处理）

将我们从执行者转变为指挥者

类的组成

类由两部分组成：类名、类体

类体由两部分组成：属性（变量）与行为（方法）

//类的组成 
//类名Student  类体{}
public class Student {
	// 类体由属性与行为组成
	// 属性=》变量
	// 语法：修饰符 数据类型 属性名[=默认值];
	// []中的内容可以省略
	public String name;// 姓名
	public char sex;// 性别
	public int age;// 年龄

	// 行为=》方法
	// 语法：修饰符 返回值类型 方法名(参数列表){方法体}
	// 学习方法
	public void study() {
		System.out.println("一天不学习浑身难受");
	}

	// 吃饭方法
	public void eat() {
		System.out.println(name+"吃饭");
	}

	// 睡觉方法
	public void sleep() {
		System.out.println("睡觉");
	} 
}

类的使用
//类的使用
//对象是用来描绘具体事物的
//类是一群对象共性（属性、行为）的结合
//创建对象
//语法
//类类型(数据类型) 类变量名 =new 类类型();
Student s=new Student();
//new关键字 代表调用指定类的构造方法创建一个新的指定对象
//并为对象所有属性赋初始值int=>0 double=>0.0 boolean=>false String=>null

//属性的使用
		//语法  
		//赋值：类变量名.属性名=值;
		//获取指定对象指定属性的值  类变量名.属性名;
		s.name="张三";
		System.out.println(s.name);
		
		//方法的使用
		//语法
		//类变量名.方法名(参数列表)
		s.eat(); 

形参和实参的概念

形参：全称为“形式参数”，是在定义方法名和方法体的时候使用的参数，用于接收调用该方法时传入的实际值
实参：全称为“实际参数”，是在调用方法时传递给该方法的实际值

在方法调用过程中，实际上就是讲实参传递给形参进赋值之后使用，遵循数据类型间的转换

类与对象的关系

1.类是创建对象的模板

2.对象是类在客观世界具体存在的事物

3.类是大量对象共性（属性、行为）的抽象

对象与对象的关系

Student s1=new Student();
		Student s2=new Student();
		
		System.out.println(s1==s2);
		//new关键字会创建新的对象，就算两对象所有属性值都相等那也不是同一个对象
		
		Student s3=s1;
		System.out.println(s3);
		System.out.println(s1);
		System.out.println(s1==s3);
		s3.name="张三";
		
		System.out.println(s1.name);
		System.out.println(s3.name);