一.循环的使用
循环主要有三种: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;
}
}