方法、数组、面向对象、构造方法、封装、static关键字等相关内容

1.do-while循环语句的格式
初始化语句;
do{
循环体语句;
步长语句
}while(条件表达式) ;
do-while循环语句和for,while循环的最大的区别就是:循环体至少执行一次(条件不满足的情况)
for,while,do-while循环
开发中:常用for循环,其次是while循环,do-while使用很少,以后在java源码中会见到这个语句!
2.for循环的嵌套:
for循环语句作为循环体语句;
for(初始化语句;条件表达式;步长语句){
//循环体语句
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
}
例：打印九九乘法表

class   Tables{
		public static void main(String[] args){
			for(int i=1;i<=9;i++){
				for(int j=1;j<=i;j++){
					System.out.print(j+"*"+i+"="+(i*j)+"\t");
				}
				System.out.println();
		}
	}
}

3.跳转控制语句break,continue,return
(1)break:表示结束,中断的意思
break:单独使用,没有意义(存在问题),只能switch语句或者循环语句中使用!
如果while(true)和switch一块使用的时候：
注意小细节:break此时只能结束switch语句,while(true)的结束,可以使用System.exit(0) ;
break应用场景:只能switch语句或者循环语句中使用!
情况1:中断结束单层循环
情况2:中断结束多层循环(早期使用)
(2)continue::继续 (结束当前循环,立即进入下一次循环)
单独使用:没有意义, continue 在 loop 外部(循环中使用)
（3）return :一般很少单独使用,一般结束方法使用的。
return是结合方法去使用的,如果一个方法中有return,具体返回结果;如果没有，则会报错！

方法（函数）

1.什么是方法？
就是用{}（大括号）包起来的内容，给{}独立的代码块起一个名字，以便复用。
2.定义方法的格式及调用：
情况1：有具体返回值类型的方法定义
格式： 权限修饰符 静态修饰符 返回值类型 方法名(参数类型1 变量名1，参数类型2 变量名2，……){
//业务内容；
有return
}
情况2：没有具体返回值的方法定义
格式：修饰符（public static） void 方法名(参数类型1 变量名1，参数类型2 变量名2，……){
//要么输出结果，要么其他相关业务功能。
没有return
}
3.调用的方法：
单独调用：没有意义
输出调用：不推荐
赋值调用：推荐
4.定义方法时两个明确：
（1）明确返回值类型：如果有返回值，则根据所接收的返回值定义它的类型。若无返回值则用void代替。
（2）明确参数类型及参数个数。
5.定义方法及调用方法的注意事项：
（1）方法和方法是平级关系，不能在一个方法中定义另一个方法。
（2）在定义方法的时候，（目前来说），必须带上static关键字。
（3）定义的时候，形式参数必须带上数据类型。

方法重载

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

数组

1.数组概念：数组是一种“容器”，可以存储同一种类型的元素的已知“容器”。
注意：必须保证该容器中存储的类型必须一致！
2.数组的定义：
数据类型[] 数组名称；
数据类型 数组名称[];
3.数组的初始化：
（1）动态初始化：开发者在定义数组初始化的时候，指定数组的长度，系统默认给数组中的元素赋值。
（2）静态初始化：直接指定数组的元素内容，系统指定的数组长度。
4.数组初始化格式：
数据类型[] 数组名称=new 数据类型[数据长度];
数据类型 数组名称[]=new 数据类型[数据长度];
数据类型[] 数组名称={元素1,元素2……};
例如：
动态初始化：
int[] arr=new int[3]; arr[0]=10; arr[1]=20; arr[2]=30;
静态初始化：

int[] arr = {12,13,24……};

5.数组中会遇到的一些异常：
运行异常：（1）java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常。
出现原因：访问了数组中不存在的角标值。
解决方案：更改角标在范围内即可。
（2）Error:程序出现严重问题。
（3）RuntimeException:运行时期异常。
（4）java.lang.NullPointerException:空指针异常（引用类型中经常出现）
6.数组的应用
例：键盘录入数组元素，并将数组逆序、遍历、冒泡排序、求最大值、求角标值

import java.util.Scanner;
public class ArrayTest{
	public static void main(String[] args){
   		//获取数组元素
   		Scanner input = new Scanner(System.in);
   		//提示并接收
   		System.out.println("请输入第一个元素：");
   		int a = input.nextInt();
   		System.out.println("请输入第二个元素：");
   		int b= input.nextInt();
   		System.out.println("请输入第三个元素：");
   		int c = input.nextInt();
   		System.out.println("请输入第四个元素：");
   		int d = input.nextInt();
   		System.out.println("请输入第五个元素：");
   		int e = input.nextInt();
   		//定义一个数组并初始化
   		int[] arr={a,b,c,d,e};
   		//调用方法
   		opposite(arr);
   		array(arr);
   		int max = getMax(arr);
   		int index = getIndex(arr,d);
   		System.out.println("最大值为"+max+"   角标为："+index);
   }
   /*
	两个明确：1.没有返回值类型  2.1个参数  int类型数组
	*/
	//遍历
	public static void array(int[] arr){
		for(int i=0;i<arr.length;i++){
			if(i==arr.length-1){
				System.out.print(arr[i]+"]");
			}else{
				System.out.print(arr[i]+", ");
			}
		}
	}
	//逆序
	public static void opposite(int[] arr){
		for(int i=0,j=arr.length-1;i<=j;i++j--){
			int temp = arr[i];
			arr[i]=arr[j];
			arr[j]=temp;
		}
	}
	//求最值
	public static int getMax(int[] arr){
		//定义最大值并初始化
		int max = 0;
		for(int i=0;i<arr.length;i++){
			if(arr[i]>max){
			max=arr[i];
			}
		}
		return max;
	}
	//求角标值
	public static int getKey(int[] arr,int key){
		int index = -1;
		for(int i=0;i<arr.length;i++){
			if(arr[i]=key){
				index=i;
				break;
			}
		}
		return index;
	}
}

7.面试题
数组中有没有length属性、字符串里面有没有length属性、集合里面有没有length属性？
答案：数组里面有；字符串里面没有length属性，但有length()方法；集合里面没有length属性，有size()方法。
8.冒泡排序的思想：
两两比较，大的值往后放，第一次比较完毕后，最大值就出现在最大索引处，依次这样比较，就可以得到排好序的数组了。
注：总共比较的次数=数组的长度-1.

二维数组

1.初始化格式：
数据类型[][] 数组名称=new 数据类型[m][n];
数据类型 数组名称[][] = new 数据类型[m][n];
注意：m表示以为数组的个数，n表示一维数组的长度。
例如：静态初始化（推荐）：int[][] arr = {{元素1，元素2……},{元素1，元素2……},{元素1，元素2……},……};
动态初始化：int[][] arr = new int[3][4];
例题：遍历二维数组

public class ArrayOpposite{
	public static void main(String[] args){
		int[][] arr = {{12,3,4},{3,4,25},{44,2,6}};
		opposite(arr);
	}
	//遍历二维数组
	public static void opposite(int[][] arr){
		System.out.print("{");
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr[i].length;j++){
				if(j==arr[i].length-1){
					System.out.print(arr[i][j]);
				}else{
					System.out.print(arr[i][j]+", ");
				}
			}
		}
		System.out.println("}");
	}
}

2.思考题：
方法的形式参数分别是：基本数据类型和引用数据类型之区别。
答案：方法的形式参数如果传递的是基本数据类型，形式参数的改变对实际参数没有影响；方法的形式参数如果传递的是引用数据类型，形式参数的改变会直接影响实际参数；String是引用类型，他如果作为形式参数的特点跟基本数据类型一样。

面向对象

1.什么是面向对象？
基于面向过程的一种思想。强调对象的创建，使用对象调用的功能。
2.面向对象的思想特点：
1）更符合生活中的思想行为习惯。
2）让复杂的事情简单化。
3）让我们从执行者变成指挥者。
3.面向对象的设计原则：
不断创建对象，使用对象，指挥该对象做事情。
4.面向对象的三大特征
封装、继承、多态。（具体后面详细介绍）
5.类和事物的关系：
事物：描述现实世界的真实存在泛指的东西。
类：是描述一组事物的特征和行为的集合。
6.实例

/*
	需求:
		手机事物
		    属性:品牌(brand),价格(price),颜色(color),内存(memory)
			行为:打电话,玩游戏,聊天
			
	定义一个手机类(Phone),然后去测试手机类
*/
//定义一个手机测试类
class PhoneTest{
	public static void main(String[] args){
		//创建该对象     类名  对象名 = new 类名;
		Phone phone = new Phone();
		//对象名访问成员变量
		phone.brand="华为nove7";
		phone.price=3999.99;
		phone.color="银色";
		phone.memory=16;
		System.out.println(phone.brand+"--"+phone.price+"--"+phone.color+"--"+phone.memory);
		//对象名访问成员方法
		phone.phone("小穆");
		phone.playGame("吃鸡了");
		phone.chart("小马老师");
	}
}

//定义手机类
class Phone{
	//定义成员变量：类中方法外
	String brand;//品牌
	double price;
	String color;
	int memory;//内存
	//成员方法
	public void phone(String name){
		System.out.println("可以跟"+name+"打电话了");
	}
	public void playGame(String name){
		System.out.println("可以打"+name);
	}
	public void chart(String name){
		System.out.println("可以和"+name+"聊天了");
	}
}

7.成员变量和局部变量的区别：
1）在类中的位置不同：
局部变量：在方法的定义上或者方法的声明上的变量。
成员变量：在类中、方法外定义的变量。
2）在内存中的位置不同：
局部变量：在栈中存储。
成员变量：在堆中存储。
3）生命周期不同
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
成员变量：随着对象的创建而存在，随着对象的创建完毕而使用完毕，等待垃圾回收器GC收掉之后才消失。
4）初始化时机不同
局部变量：必须在使用前初始化。
成员变量：跟对象有关，在堆中存在，即使没有初始化，系统也会默认初始化。
注：属性、实例变量、成员变量等价；实力方法、成员方法等价。
成员变量的默认值：整数：0 小数：0.0 字符：\u000 布尔：false 其他：null

构造方法

1.构造方法：类中的特殊方法，主要用于创建对象。
2.特点：
1)方法名与类名完全相同。
2)没有返回值类型。
3）并且连void都没有。
3.对象的创建过程
1）内存中开辟对象空间；
2）为各个属性赋初值；
3）执行构造方法中的代码；
4）将对象的地址赋值给变量。
注意：如果手动添加过有参构造方法，则系统不再默认提供无参构造方法，建议手动添加。
例如：给出学生的姓名、年龄、性别、成绩属性，利用构造方法去显示并打印出来。

//测试类
class TestStudent{
	public static void main(String[] args){
		Student s = new Student("array",23,"男",99.0);
		System.out.println(s.name+"--"+s.age+"--"+s.sex+"--"+s.score);
	}
}

//学生类
//构造方法
class Student{
	//定义成员变量
	String name;
	int age;
	String sex;
	double score;
	//构造方法的方法名和类名相同
	public Student(){}//无参构造，手动添加
	public Student(String n,int a,String s,double sc){
		//四参构造
		//构造方法为属性赋值
		name = n;
		age = a;
		sex = s;
		score = sc;
	}
}

匿名对象

1.匿名对象：意思就是创建的对象没有名字。
2.特点：仅仅使用一次，使用完毕，从内存中立即被释放掉；匿名对象也可以作为实参传递。
注意：使用匿名对象的时候不要使用多次。
3.格式： new 类名(); 前提条件，该类是一个具体类。
例如：创建一个学生类

//自定义一个学生类
class Student{
	public void study(){
		System.out.println("好好学习,天天向上!!") ;
	}
}

//自定义StudentDemo类
class StudentDemo{
	public void method(Student s){//形式参数是一个引用类型,具体类
		s.study() ;
	}
}
//测试类
class NoNameDemo{
	public static void main(String[] args){
		//需求:访问StudentDemo类中的method方法
		//创建StudentDemo类对象    类名 对象名 = new 类名() ;
		StudentDemo sd = new StudentDemo() ;
		//创建学生类对象
		Student s = new Student() ; //对象名称叫s (有名称的对象)
		sd.method(s) ;
		System.out.println("-------------------------") ;
		
		//使用匿名对象
		sd.method(new Student()) ;  //该学生的匿名对象作为参数传递
		
		System.out.println("-------------------------") ;
		
		//链式编程(开发中不建议这样使用,阅读性差,建议分开写)
		new StudentDemo().method(new Student()) ;
		
		
	}
}

封装

1.什么是封装？
将类中的成员变量私有化，对外提供公共的访问方法（权限足够大）。
注意：私有化的成员变量只能在本类中访问，外界不能访问。
2.private关键字的特点：
1）private可以修饰一个类中的成员变量，也可以修饰成员方法。
2）被private修饰的成员变量和成员方法只能在本类中使用，外界不能访问！（保证数据的安全性），但是若要访问，只能通过公共方法间接访问。
3.一个标准类的写法：
1）属性私有化
2）对外提供公共的访问setXXX()和getXXX()方法
3）构造方法。
例1：定义一个动物类Animal，动物类中有name属性，age属性，color属性。按照标准类的书写该类，并且提供AnimalTest测试。（setXXX()方法赋值）

//定义一个动物类
class Animal{
	//定义动物属性私有化
	private String name;
	private int age;
	private String color;
	//setXXX()方法
	public void setName(String name){
		this.name=name;
	}
	public void setAge(int age){
		this.age=age;
	} 
	public void setColor(String color){
		this.color=color;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public String getColor(){
		return color;
	}
}
//测试类
class AnimalTest{
	public static void main(String[] args){
		//创建成员对象
		Animal a = new Animal();
		a.setName("哈士奇");
		a.setAge(3);
		a.setColor("棕红色");
		System.out.println("名字："+a.getName()+"  岁数："+a.getAge()+"岁  毛色："+a.getColor());
	}
}

例2.定义一个员工类,自己分析出几个成员，然后给出成员变量，构造方法，getXxx()/setXxx()方法，
以及一 个显示所有成员信息的方法。并测试。（使用构造方法）

//测试类
class WorkTest{
	public static void main(String[] args){
		//创建对象
		Work w1 = new Work("0001","张帆","男",22);
		w1.show();
		Work w2 = new Work("0002","穆海龙","男",24);
		w1.show();
		Work w3 = new Work("0003","任北平","男",24);
		w1.show();
		System.out.println("-----------------------");
		Work w = new Work();
		w.setId("0004");
		w.setName("周杰伦");
		w.setSex("男");
		w.setAge(60);
		w.show();
	}
}
//员工类
class Work{
	//私有化变量
	private String id;//员工编号
	private String name;
	private String sex;
	private int age;
	//构造方法
	public Work(){}
	public Work(String id,String name,String sex,int age){
		this.id=id;
		this.name=name;
		this.sex=sex;
		this.age=age;
	}
	public void show(){
		System.out.println("员工编号："+id+"  员工姓名："+name+"  性别："+sex+"  年龄："+age);
	}
	//setXXX()方法赋值
	public void setId(String id){
		this.id=id;
	}
	public void setName(String name){
		this.name=name;
	}
	public void setSex(String sex){
		this.sex=sex;
	}
	public void setAge(int age){
		this.age=age;
	}
	//getXXX获取值
	public String getId(){
		return id;
	}
	public String getName(){
		return name;
	}
	public String getSex(){
		return sex;
	}
	public int getAge(){
		return age;
	}
}

静态修饰符static关键字

1.关于静态修饰符static的特点：
1）被static修饰的变量或者方法，都随着类的就加载而加载。
2）被static修饰的优先于对象存在。
3）被static修饰的可以被多个对象共用、共享。
4）被静态修饰符修饰的成员方法或者成员变量可以被类名直接访问（推荐方式）；但也可以用类对象来访问该成员（不推荐）。
2.使用static关键字的注意事项：
1）在static中，是没有this关键字的！（this代表当前对象地址值，对象已创建了而static修饰的和类有关）。
2）关于成员方法访问问题：
非静态成员方法：
既可以访问静态成员变量、静态成员方法，也可以访问非静态成员变量、非静态成员方法。
静态成员方法：
静态成员方法只能访问静态变量和静态方法，不能访问非静态成员变量和非静态成员方法。
3.面试题
Student s = new Student();做了那些事？
解答：1）加载Student.class进内存；
2）在栈内存中开辟一个栈内存空间；
3）在对内存中申请空间；
4）对数据进行初始化（成员变量）；
（1）系统默认初始化；
（2）显示初始化------>setXXX(形参)/构造方法赋值；
5）在堆内存申请空间完毕，产生一个堆内存地址；
6）将堆内存地址赋值给栈内存变量s；
7）栈内存变量s指向堆内存地址。
例如：
需求:
定义一个人类，属性:姓名,年龄,国籍，定义一个测试类测试这个"人类"，按照上面这个需求,测试之后,发现这四个人都"中国",从内存角度考虑,“中国"在堆内存中比较耗费内存空间，如何优化:想办法让着多个人共用一个国籍"中国”
Java提供了一个关键字:static “静态修饰符”

//定义一个人类
class Person{
	//定义三个成员变量
	String name ;		//null
	int age ;			//0
	//String country ;	//null
	static String country ;
	
	//提供两个参数的有参构造
	public Person(String name,int age){
		this.name = name ;
		this.age = age; 
	}
	
	//带三个参数的构造方法
	public Person(String name,int age,String country){
		this.name = name ;
		this.age = age ;
		this.country = country ;
	}
	
	//提供一个成员方法:show(),将成员变量输出
	public void show(){
		System.out.println("姓名是:"+name+",年龄是:"+age+",所在的国籍是:"+country);
	}
}
//测试类
class PersonTest{
	public static void main(String[] args){
		//古代四大美女
		//创建对象
		Person p1 = new Person("貂蝉",25,"中国") ;
		p1.show() ;
		System.out.println("------------------") ;
		//Person p2 = new Person("西施",22,"中国") ;
		//改进:
		Person p2 = new Person("西施",22) ;
		p2.show() ;
		System.out.println("------------------") ;
		//Person p3 = new Person("杨玉环",20,"中国") ;
		//改进:
		Person p3 = new Person("杨玉环",20) ;
		p3.show() ;
		System.out.println("------------------") ;
		//Person p4 = new Person("王昭君",28,"中国") ;
		Person p4 = new Person("王昭君",28) ;
		p4.show() ;
		System.out.println("------------------") ;
		//通过第四个Person对象 p4访问country
		p4.country = "美国" ;
		p4.show() ;
		p3.show();
		p2.show();
		p1.show();
	}
}