循环、一维数组、方法、面向对象、封装、构造、重载、

一：循环语句

循环语句包含for循环与while循环

1.1 for循环（已知循环次数时使用）

1.1.1单循环

格式：
	for(初始化变量;循环条件判断;控制体语句){
	语句体
	}
例子：打印三次数据
	for(int i=1;i<=3){
		System.out.println("打印第"+i+"次")
	}

1.1.2嵌套循环
嵌套循环就是在外层循环语句体重再次书写一个循环（外层循环控制循环次数，内层循环控制逻辑语句）。

格式：
	for（初始化变量; 循环条件; 控制体语句）{
		for(初始化变量; 循环条件; 控制体语句){
			循环体语句；
		}
	}
例子：乘法口诀表
	public static void main(String[] args){
		for(int i = 1; i<10;i++){//循环次数
			for(int j = 1;j<=i;j++){
				System.out.print(j+"*"+i+"="+(i*j))
			}
			System.out.println();
		}
	}

1.2while循环

循环次数未知时建议使用

格式：
	while(判断条件){
		循环体语句；
		控制体语句（i++）；
	}

例子：
	public static void main(String[] args){
		int i=1;
		while(i<=10){
		System.out.println("打印第"+i+"次")
		i++;
		}
	}
	

1.3do – while

特点：不管满不满足条件循环语句体先执行一次

格式：
	do{
		循环体语句;
		控制体语句;
	}while(条件表达式) ;
例子：
	public static void main(String[] args){
		int i=1;
		do{
			System.out.println("abc");
			i++;
		}while(i<1)
	}

1.4死循环

在开发中需要合理使用死循环结构，必须要在满足某个条件后跳出循环

格式：
for(;;){
	if(条件语句){
		语句体;
		break;
	}
}

while(ture){
	//条件判断语句体
		if(条件语句){
		语句体;
		break;
	}
	i++;
}

1.5：关键字的使用方式（break、return、continue）

1.5.1：break
结束当前循环

例子：
	当i==8的时候结束当前循环
	public static void main(String[] args){
		for(int i=0; i<10;i++){
			if(i==8){
				break;
			}
			System.out.println(){}
		}
	}

1.5.2：continue
跳过本次循环，继续执行下次循环
1.5.1：return
结束当前方法

二：一维数组

数组内的数据格式必须与定义格式一致。

2.1动态定义数组

格式：
数组类型 数组名称[] = new 数组类型 [ 数组长度 ];
数组类型 []数组名称 = new 数组类型 [ 数组长度 ];

2.2静态定义数组

格式：
数组类型 [] 数组名称 = {}；
数组类型 数组名称 [] = new 数组类型{}；

2.3遍历数组

public static void main(String[] args){
	int arr[] = {22,99,88,77,66,44,33};
	System.out.print("[");
	for(int i=0;i<=arr.length-1;i++){
		if(i==arr.length-1){
			System.out.print(arr[arr.length-1]+"]");
		}else{
			System.out.print(arr[i]+",");
		}
	}
}

2.4冒泡排序

首先是两两比较，大的向后移。

public static void main(String[] args){
	int arr[] = new int{127,128,64,52,39};
	for(int i=0; i<arr.length-1;i++){
		int tem = 0;
		for(int j=0;j<=arr.length-1-i;j++){
			if(arr[j]>arr[j+1]){
				tem= arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tem;
			}
		}
	} 
}

三：方法

方法就是实现某一个功能所需代码的集合便于复用。

开发时定义方法名称需要遵循如下规则：

1. 见名知意；
2. 小驼峰命名规则

3.1无参无返回值

特点 ：

1. 不需要输入参数也不会返回数据的方法。
2. 传入的参数类型使用void代替
3. 形参数据列表为空

格式： public static void 方法名（）{}

3.2有参无返回值

特点：

1. 调用方法需要传递参数。
2. 传递的参数需要与方法定义的形式参数类型一致
3. 返回值为空，返回值类型void代替

格式：
public static void 方法名（形式参数列表）{}

形式参数列表是基本数据类型

**形式参数列表：**调用方法时需要传递的数据。

	形参的基本数据类型：shout、int、long、float、double、
String、boolean
	形式参数的改变不会影响到实参

形式参数列表是引用数据类型

数组、方法、类

String类型:
	特殊的引用类型:它作为形式参数,效果和基本数据类型一致!形式参数
的改变不影响实际参数(String本质就是常量)

3.3有参有返回值

调用方法，需要向该方法传递形式参数列表。方法执行完成后return返回一个值，该值与定义方法时书写的返回值类型相同

格式：public static int[]方法名（）{}

package work.day08.Test;
import com.sun.org.apache.bcel.internal.generic.NEW;
public class Demo {
//遍历数组并在控制台打印
/*
void：返回值为空；
		（int arr[]）：形式参数列表的入参是“int arr[]”
*/
    public static void getPrintArr(int arr[]) {
        System.out.print("[");
        for(int i=0;i<=arr.length-1;i++){
            if(i==arr.length-1){
                System.out.print(arr[arr.length-1]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
    }
    /*
int[]：返回值为int类型的数组arr；
		（int arr[]）：形式参数列表的入参是“int arr[]”
*/
    public static int[] setSort(int arr[]){

        for (int i = 0; i <=arr.length - 1; i++) {
            int tem = 0;
            for (int j = 0; j <arr.length - 1 - i; j++) {
              if (arr[j]>arr[j+1]){
                  tem = arr[j];
                  arr[j] = arr[j + 1];
                  arr[j + 1] = tem;
              }
            }
        }
        return arr;
    }
    
    public static void main(String[] args) {
       int arr[] = {22,66,8,99,77,44,55};
        getPrintArr(setSort(arr));
    }
}

3.4面向对象

什么是面向对象？

	面向对象就是一个函数类下包含多个功能方法，需要其中某一个
功能方法代码时打点调用即可

面向对象的特征：

 1. 继承
 2. 多态
 3. 封装

封装
什么是封装？

	将成员变量私有化，如果需要访问则需要使用该类中提供的方法进行
间接访问。
关键字：
	private：私有的。只能本类中的方法访问 。get、set方法访问赋值
			 与打印

局部变量与成员变量的区别

1.书写位置：
 - 成员变量：书写在类中方法之外
 - 局部变量：方法之中
2.存储
 - 成员变量：存储在堆内存中
 - 局部变量：存储在栈内存中
3.生命周期
 - 成员变量：在堆内存中，随着对象的创建完成不会立即被回收需要等到Gc空闲时间回收
 - 局部变量：随着方法调用而存在,随着方法调用完毕而消失
4.初始化不同
 - 成员变量：编译时如果成员变量未赋值系统给出默认值。
 - 局部变量：编译时如果局部变量未赋值则编译报错。

	

例子：
class Demo{
	//成员变量定义在类中方法之外
	private int age;
	private String name;
	//成员变量赋值
	public void setName( String name){
		this.name=name;
	}
	//成员变量访问
	public String getName(){
		return name;
	}
	public void setAge(String age){
		if(age<0 || age>150){
			System.out.println("请确认您输入的年龄");
		}else{
			this.age= age;
		}
	}
	public String getAge(){
		return age;
	}
	
}

class DemoTest{
	public static void main(String[] args){
		//创建Demo的对象
		Demo demo = new Demo();
		//给name赋值
		demo.setName("张三");
		//给age赋值并判断该值是否合法
		demo.setAge(55);
		System.out.println("姓名是："+demo.getName+",年龄是：
		"+demo.getAge);
	}
}

3.5方法的重载

什么是方法的重载？
1. 方法的名称一致；
2. 形式参数列表不同（类型、个数）
3. 与返回值类型无关

public static int aetAge(int age){
	this.age= age;
	return age;
}
public static void aetAge(int age, int age1){
	this.age = age;
	this age1=age1;
}
public static double aetAge(double age){
	this.age= age;
	return age;
}
public static void main(String[] args){
	
}

3.6匿名方法

**匿名方法：**没有地址指向的方法
格式： new 类名;

特点：

1. 匿名方法只能使用一次，再次使用需要重新new
2. 匿名方法存储与堆内存中没有指向性地址，使用一次后立即回收

3.7构造方法

什么是构造方法？

1. 方法名称与类名相同
2. 返回值为空时void不需要书写

格式：

1. public 类名(){}
2. public 类名(形参){}

注意：

1. 构造方法无返回值
2. 在构造方法中不能使用return
3. 当自定义了构造方法之后，编译器就不在自动创建无参的构造

package work.day09;
class Demo{
    private int age;
    private String nanme;
    //无参构造
    public Demo(){
        this.age=30;
        this.nanme="zhangsan";
    }
    //有参构造
    public Demo(int age, String name){
        this.age=age;
        this.nanme=nanme;
    }
    //访问成员变量
    public int getAge(){
        return age;
    }
    public String getNanme(){
        return nanme;
    }

}
 class DemoTest {
    public static void main(String[] args){
        Demo d = new Demo();
        Demo d2 = new Demo(55,"李四");
        System.out.println("姓名是："+d.getNanme()+"，年龄
        是 "+d.getAge());
        System.out.println("姓名是："+d2 .getNanme()+"，年龄
        是 "+d2.getAge());
    }
}

3.8标准类

//测试类
package work.day09;
class DemoTest{
    public static void main(String[] args) {
        Demo demo = new Demo();
        Demo demo1 = new Demo(77.5, 10);
        //无参构造计算周长
        System.out.println(demo.getPerimeter(demo.getLong(),demo.getWide()));
        //无参构造计算面积
        System.out.println(demo.getMeasureOfArea(demo.getLong(),demo.getWide()));
        // 有参构造计算周长
        System.out.println(demo1.getPerimeter(demo1.getLong(),demo1.getWide()));
        // 有参构造计算面积
        System.out.println(demo1.getMeasureOfArea(demo1.getLong(),demo1.getWide()));
    }

}

class Demo {
    private double Long ;
    private double wide;
    public double getLong() {
        return Long;
    }
    public void setLong(double Long) {
        if(Long<0){
            System.out.println("请确认后再次输入长度");
        }else {
            Long = Long;
        }
    }
    public double getWide() {
        return wide;
    }
    public void setWide(double wide) {
        if (wide < 0) {
            System.out.println("请确认后再次输入宽度");
        } else {
            this.wide = wide;
        }
    }

    public Demo(){
        this.wide=10;
        this.Long=20;
    }
    public Demo(double Long, double wide){
        this.Long=Long;
        this.wide=wide;
    }
    //计算周长
    public double getPerimeter(double Long,double wide) {
        return (Long + wide) * 2;
    }

    //计算面积
    public double getMeasureOfArea(double Long,double wide){
        return Long*wide;
    }

}