Java学习day3~4

一.循环的使用

循环主要有三种：for  ||  while || do-while

for循环在有明确循环次数时使用最方便，基本语法为：

for(初始化语句;条件表达式;步长语句/控制体语句 ++/--) { 		
	循环体语句;
}

for循环语句的执行流程
  1.初始化语句给当前变量进行赋值
  2.执行条件表达式语句,如果条件表达式语句成立(true),执行循环体语句
  3.循环体语句执行完毕之后,在执行步长语句,再次执行条件表达式语句,如果成立(true),再一次循环体语句

  4.一直到条件表达式语句不成立(false),for循环语句结束

while循环在不知道具体循环次数的时候适合，基本语法为：

while(条件表达式) {
	循环体语句;
	长语句;
}
 

执行流程：先判断条件，条件符合（true）则执行循环体语句，一会执行，直到条件不成立结束

do-while循环，基本是三个之中最后一个考虑应用的，基本语法为：

do {
	循环体语句;
	步长语句;
} while(条件表达式) ;

执行流程：先执行循环体里面的语句，然后进行条件判断，如果条件符合（true）则继续执行循环体语句，直至条件不符合（false）结束循环【该循环至少执行一次】

三者之间的区别：

应用场景的优先选择：for > while > do-while

明确循环次数的时候，优先选择for循环，如打印一定次数的语句，对1~100之间的数字进行求和

从内存角度考虑，for循环优于while循环，for循环语句结束之后，变量就会被jvm里面的GC回收掉并释放内存，内存空间不会消耗太多，而while循环，是可以访问那个变量，不会被立即回收掉

do-while循环至少会执行一次

应用举例：1.从屏幕打印10个helloworld语句

                 2.输出水仙花数

                 3.判断一定范围内的回文数

循环可以叠加使用，如打印99乘法表

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

二.数组

是可以储存多个元素的容器，这些元素必须是同一种类型

数组的定义：  数据类型[]  数组名称；            推荐使用

                      数据类型   数组名称[];               两种表达效果是一样的

数组的初始化：1.动态初始化：指定数组长度，由系统给数组中的元素赋值

                            eg:  数据类型[]  数组名称 = new 数据类型[指定长度] ;             int[] arr = new int[3] ;

                            其中，=左边，int表示是int类型的数组，[]表示该数组是一维数组，arr表示数组名称（对象名称）

                                      =右边，new是创建一个数组对象（在堆中开辟空间）， []是一维数组

                         ~创建两个动态数组，其内存分配图解如下~

                        2.静态初始化：指定数组中的元素的值，由系统给数组指定长度

数组名称即数组首地址，数组下标从0开始，最大为数组长度减一，

可以通过数组下标访问元素，如arr[2]是下标为2的第三个元素

三.跳转控制语句:

          break: 中断,结束在循环语句以及switch语句中使用最多

          continue: 结束当前循环,立即进入一次循环     应用场景:在循环语句中使用

          return: 和方法返回值有关,结束整个方法

四.java中的内存分配图解

五.成员变量和局部变量

局部变量和成员变量的区别?
  1.书写的位置不同
   局部变量:在方法中或者是方法声明上!
成员变量:在类中方法外
   2.在内存中的位置不同
   局部变量:在栈内存中
   成员变量:在堆内存中
   2.生命周期:
   局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
   成员变量:随着类的加载而存在,随着类的加载完毕,等待gC回收
   2.初始化不同
   局部变量:不能不初始化,即使是声明一个局部变量,使用之前必须初始化,否则报错!
  成员变量:可以不用初始化值;

六.java中的方法

	方法:执行特定功能的独立的代码块!(有一个方法名)
	定义方法 格式:		(有具体返回值的方法的定义)
	修饰符  返回值  方法名(形式参数列表…) {
		return  表达式;
        }

定义方法要明确返回值类型，参数类型及参数个数

定义方法的注意事项:

1)      方法和方法之间是平级关系,可以在一个方法中调用另一个方法,但是不能再该方法中定义发方法

2)      形式参数中,参数名携带数据类型,否则报错

3)      在调用方法的时候,方法名(实际参数列表) ;实际参数不需要携带数据类型

4)      public staticint sum(int a,int b);{…} :这种方法是没有方法体的方法 ,不能有分号;

构造方法:
   特点:1.方法名和类名相同
   2.没有返回值类型,连void都没有

   3.没有具体的返回值

        注意：什么都不写，系统会默认提供无参构造方法，如果手动添加有参构造方法，系统不再默认提供无参构造方法，但是                      建议自己手动再添加午餐构造方法，如果成员变量名称和局部变量名称一致的情况下,采用就近原则!

        作用：初始化成员变量

七.对象的内存分配

public class PhoneTest {  //javac PhoneTest.java---->PhoneTest.class---->java PhoneTest
	
	public static void main(String[] args) {
		//创建一个手机类对象
		Phone p = new Phone() ;
		System.out.println(p.brand+"---"+p.price+"----"+p.color) ;
		
		//给成员变量赋值
		p.brand = "小米";
		p.price = 1999 ;
		p.color = "红色";
		System.out.println(p.brand+"---"+p.price+"----"+p.color) ;
		
		//调用方法
		p.callPhone("高圆圆");
		p.sendMessage();
		p.playGame();
	}
}


class Phone {
	
	//提供成员变量
	String brand;//品牌
	int price;//价格
	String color;//颜色
	 
	/*public Phone() {  //构造方法.给对象进行初始化的 (系统默认提供无参构造)
		
	}*/
	
	//成员方法
	public void callPhone(String name) {
		System.out.println("给"+name+"打电话");
	}
	
	public void sendMessage() {
		System.out.println("手机可以发短信了...");
	}
	
	public void playGame() {
		System.out.println("手机可以玩游戏...");
	}
}

八.封装

即将一个类中的成员变量私有化,对该类提供一些公共的访问方法

关于private关键字:
private :私有的,不能访问的
被private修饰的成员变量/成员方法,只能在本类中访问,外界不能够直接访问

封装的好处：提高程序的安全性，如提供公共的get、set方法

九.匿名对象

匿名对象:没有名字对象
实际开发中,在接口中,抽象类 中用的非常多
格式：   new 类名() ;
匿名对象的好处:
1.一般,调用一次即可,不适合调用多次
2.调用完毕之后,会立即从内存释放掉,及时被GC垃圾回收器回收掉!

3.匿名对象它可以作为参数进行传递

十.形式参数问题

1.形式参数如果是基本数据类型: 形式参数的改变,对实际参数没有影响

2.形式参数是应用数据类型的话:形式参的改变,会直接影响实际参数

class Demo{
	
	//求两个数据之和
//	public int sum(int a,int b) {
	public int sum(double a,int b) {
		return (int) (a+b) ;
	}
}

//自定义个学生类
class Student{
	public void study() {
		System.out.println("Good Good Study,Day Day Up!!!");
	}
}
//自定义一个类
 class StudentMethod{
	//带有引用类型的参数的方法
	public void method(Student s) { //需要Student s= new Student() ;	
		s.study();
	}	
}
public class StudentDemo {
	
	public static void main(String[] args) {
		
		//需要调用sum()方法
		//创建Demo类对象
		Demo d = new Demo() ;
//		int result = d.sum(10, 20) ;
		int result = d.sum(10.01, 20); //是什么类型,就穿具体的那个类型的值即可!
		System.out.println(result);
		System.out.println("-------------------");
		
		//需求:需要调用StudentMethod这个类中的method()方法
		//1)创建StudentMethod类的对象
		//2)调用method()
		StudentMethod sm = new StudentMethod() ;
//		sm.method(s);/s cannot be resolved to a variable
		//需要创建Student对象
		Student s = new Student() ;
		sm.method(s);
	}
}

如何看出形参的类型决定实参的变化呢？举两个例子，代码如下：

1.形参是基本数据类型

//形参为int(基本数据类型)时，形参的改变不影响实参
public class test {
	public static void main(String[] args) {
		int i = 10;
		m1(i);
		System.out.println(i); //11
	}
	
	public static void m1(int i) {
		i++;
		System.out.println(i);  //10,虽然传过去的i进行了自增一操作，但是main方法中的i仍未改变
	}
}

2.形参是引用数据类型

//形参为引用类型时，形参的改变会影响实参
public class test {
	public static void main(String[] args) {
		Student s = new Student(20);  //创建一个Student类型对象s，20是实参
		m1(s);	//将s作为参数传入，进行自增操作，所以m1中为21
		System.out.println(s.age);  //21   主方法中的age也被改变
	}
	
	public static void m1(Student s) {
		s.age++;
		System.out.println(s.age);  //21
	}
}

class Student {
	int age;
	
	Student(int age) {
		this.age = age;
	}
}