1.流程控制语句
2.方法
3.数组
4.形式参数
5.面向对象
6.封装
1.流程控制语句(if & switch week_1).
1) for循环
格式:
for(初始化语句;条件表达式;步长/控制体语句){
循环体语句;
}
执行流程:
a.执行初始化语句;
b.若满足条件,执行循环体语句;
c.执行步长/控制体语句;
d.再次执行(b)的过程,若条件满足,一直执行下去,直到条件表达式不成立,for循环结束.
例1:
求1-10之间整数的和.
int sum = 0;
for(int a = 1;a <= 10;a++){ //→满足条件,执行sum=sum+a,a++
sum = sum +a ;
}
System.out.println("和为:"+sum);
例2:
求所有水仙花数.
for(int x = 100;x<=999;x++){
int a = x % 10 ;
int b = x / 10 % 10;
int c = x / 10 / 10 % 10;
if((a*a*a+b*b*b+c*c*c) == x){
System.out.println("水仙花数为:"+x);
}
}
2)while
格式: (常使用在循环次数不明确的时候)
初始化语句;
while(条件表达式){
循环体语句;
控制体语句/步长语句;
}
执行流程:
1)初始化语句赋值;
2)条件表达式成立则执行循环语句,执行控制体语句;
3)再次判断条件表达式是否成立,循环执行到条件不成立while结束.
例:
int x = 1;
while(x<=10){
System.out.println("哈哈");
x++;
}
与for循环的区别:
1)循环格式上不同:for循环结束后,不能再访问for语句中的变量,for
循环结束变量需要被释放掉了;while 循环中的变量可以继续访问;
2)内存方面:for循环结束后变量被释放掉,节省内存空间;while循环
结束后依然可以访问这个变量,比较消耗内存空间.
3)死循环
格式:(结束死循环需要 break)
1)for(,,){
循环体语句;
}
2)while(true){
循环体语句;
}
例:
int num = (int)(Math.random()*100+1);
if(guessNumber>num){
System.out.println("数字猜大了");
}else if(guessNumber<num){
System.out.println("数字猜小了");
}else{
System.out.println("猜对了");
break;
}
4)do-while
格式:
do{
循环体语句;
控制体语句;
}while(条件表达式);
特点:优先执行循环语句,即使条件不成立,循环体也至少执行一次.
例:
int sum = 0;
int x = 1;
do{
sum = sum +x;
x++;
}while(x<=100);
System.out.println("1-100之间数字和为:"+sum);
5)for循环嵌套
一个for循环语句作为另一个for循环语句的循环体
格式:
for(初始化语句;条件表达式;控制体语句){
for(初始化语句;条件表达式;控制体语句){
}
}
例: 9 9 乘法表
for(int x =1;x<=9;x++){
for(int y =1;y<=x;y++){
System.out.print(x+"*"+y+"="+(x*y)+"\t");
}
System.out.println();
}
2.方法.
需要使用{}代码块将业务体包起来,并为之起一个见名知意的名字.
1)有具体返回值类型的方法
格式:
public static 返回值类型 方法名(参数类型1 变量名1,参数类型2 变量名2 ...)
方法中的业务逻辑代码
return 结果;
例:
省略 main 方法...
int a =10;
int b =20;
int result = sum (a,b);//返回值代入 sum = 30;
System.out.println(result);
public static int sum(int a,int b){
int result = a +b;
return result;
}
2)没有具体返回值类型的方法
针对某个功能代码块{}没有具体返回值类型,使用 void 代替.
格式:
public static void 方法名(形式参数列表){
方法体中的内容直接输出,或者进行其他操作(不需要return语句)
}
例: 键录入打印 n n 乘法表
次数省略类,导包和main方法...
Scanner s = new Scanner(System.in);
System.out.println("输入一个0-9的数字");
int n = s.nextInt();
cF(n);
public static void cF(int n){
for(int x = 1;x<=n;x++){
for(int y = 2;y<=x;y++){
System.out.print(x+"*"+y+"="+(x*y)+"\t");
}
System.out.println();
}
}
3)方法重载
方法名相同,参数列表不同(参数个数/参数类型),与返回值无关,目的是为了
提高某个功能的扩展性,所以有时候同一个方法可以传递任何数据类型.
例:
pulic static void open(double a,int b);
pulic static void open(int a,double b);
3.数组.
数组是存储多个数据的容器,必须保证容器中的数据类型一致.
1)定义格式
a.动态初始化
给定数组的长度,系统默认对元素进行初始化.
数据类型[] 数组名称 = new 数据类型[数组长度];
或 数据类型 数组名称[] = new 数据类型[数组长度];
例:
int[] ar = new int[3];
b.静态初始化
给定具体的元素,数据长度由系统确定.
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3...}
或 数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3...}
简化格式:
数据类型[] 数组名称 = {元素1,元素2,元素3...};
数据类型 数组名称[] = {元素1,元素2,元素3...};
例:
int[] ar = {1,2,3,4};
2)数组的遍历
将数组中的元素一一获取到并输出.
例:
......
int[] ar = {1,2,3,4,5};
System.out.print("[");
for(int x =0;x<ar.length;x++);
if(x==ar.length-1){
System.out.println(ar[x]+"]");
}else{
System.out.print(ar[x]+", ");
}
3)数组的最值
例: 数组int[] ar = {2,5,6,4,9}的最大值
int max = ar[0];
for(int x =1;x<ar.length;x++){
if(ar[x]>max){
max = ar[x];
}
}
return max;//(有具体返回值类型)
4)数组的逆序
例: 数组int[] ar = {2,5,6,4,9}逆序
int[] ar = {2,5,6,4,9};
for(int x=0;x<ar.length/2;x++){
int a = ar[x];
ar[x] = ar[x+1];
ar[x+1]= a;
}
5)数组的查表法
通过数组名称[索引值]来确定元素内容.
例： 在数组中查询某个元素第一次出现的索引值
int[] ar={13,25,19,33,27};
public static int sY(int[] ar,int a){
for(int x =0;x<ar.length;x++){
if(a==ar[x]){
return x;
}
}
}
6)数组冒泡排序
两两计较,较大的值往后放,第一次比较完毕,最大值出现在最大索引处.
int[] ar = {10,20,15,27,34};
for(int x=0;x<ar.length;x++){
if(ar[x]>ar[x+1]){
int a = ar[x];
ar[x] = ar[x+1];
ar[x+1] = a;
}
4.形式参数.
1)方法的形式参数问题
a.如果方法的形式参数是基本数据类型,形式参数的改变不会影响实际参数;
b.如果方法的形式参数是引用数据类型(Sting类型除外),形式参数的改变会影响实际参数.
5.面向对象.
1)面向对象的思想特点
a.更符合我们生活中的思想行为习惯;
b.让复杂的事情简单化;
c.我们从执行者变成了指挥者.
2)成员变量和局部变量的区别
a.程序中的书写位置不同
局部变量在方法定义中或者方发声明上;
成员变量在类中成员方法外;
b.内存位置不同
局部变量在栈内存中;
成员变量在堆内存中;
c.生命周期不同
局部变量随着方法调用而存在,随着方法结束而消失;
成员变量随着对象的创建而存在,随着对象创建完毕不会立即消失,需要
等待GC(垃圾回收器空闲时候回收掉);
d.初始化不同
局部变量在使用前必须初始化;
成员变量可以不初始化,系统默认初始化.
3)匿名对象
没有名字的对象.
格式:
new 类名();
特点:
a.可以作为参数进行传递;
b.在开发中,匿名对象使用一次即可.
例:
class Student{
public void study{
System.out.println("学习java");
}
}
class StudentDemo{
public void method(Student student){
student.study();
}
}
class NoName{
public static void main(String[] args){
StudentDemo s = new StudentDemo();
s.method(new.Student());
}
}
6.封装.
将某个类的成员属性隐藏(成员变量私有化),保证了数据的安全性,提供一个公共访问方法.
1)例:给学生类成员加入私有修饰,对外提供公共的方法setXXX/getXXX
class Student{
private String name;
private int age;
private String gender;
public void study(){
System.out.println("学习java");
}
public String play(String gameName){
return "玩"+gameName;
}
public void sport(){
System.out.println("打篮球");
}
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
public void setAge(int a){
age = a;
}
public int getAge(){
return age;
}
public void setGender(String g){
gender = g;
}
public String getGender(){
return gender;
}
}
class StudentTest{
pulic static void main(String[] args){
Student s = new Student();
s.setName("啊");
s.setAge(20);
s.setGender("公");
System.out.println("名字是:"+s.getName()+",年龄是:"+
s.getAge()+",性别是:"+s.getGender());
s.study();
String s = s.play("dnf");
System.out.println(s);
s.sport();
}
}
2)"this"关键字
this:代表当前类的对象的地址引用.
this.成员变量名 = 局部变量;
class Phone{
private String brand;
private int prince;
private String color;
public void setBrand(String brand){
this.brand = brand;
}
public String gerBrand(){
return brand;
}
public void setPrice(int price){
this.price = price;
}
public int getPrice(){
return price;
}
public void setColor(String color){
this.color = color;
}
public String gerColor(){
return color;
}
public void call(String toName){
System.out.println("给"+toName+"打电话");
}
public void study(){
System.out.println("学习java");
}
}
class PhoneTest{
public static void main(String[] args){
Phone p = new Phone;
p.setBrand("小米");
p.setPrice(200);
p.setColor;
System.out.println("品牌是:"+p.getBrand()+",价格是:"+p.getPrice()+",颜色是:"+p.getColor());
p.call("我");
p.study();
}
}
3)构造
给类的成员的一些数据进行初始化.
规则:
a.构造方法名和类名一致;
b.没有具体的返回值类型;
c.没有 void;
注意事项:
a.当代码中没有给类提供构造方法,系统会默认提供一个无参构造;
b.如果提供了有参构造方法任何一宗,系统就不会提供无参构造,需永远给 出无参构造方法.
例:
class Phone{
private String brand;
private int price;
private String color;
public Phone(){}
public Phone(String brand,int pricce,String color){
this.brand = brand ;
this.price = price;
this.color = color;
}
public void setBrand(String brand){
this.brand = brand;
}
public String getBrand(){
return brand;
}
public void setPrice(int price){
this.price = price;
}
public int gerPrice(){
return price;
}
public void setColor(String color){
this.color = color;
}
public String getPrice(){
return color;
}
}
class PhoneTest{
public static void main(String[] args){
Phone p = new Phone();
p.setBrand("小米");
p.setPrice(100);
p.setColor("黑色");
System.out.println("品牌是:"+p.getBrand()+",价格是:"+p.getPrice()+",颜色是:"+p.getColor());
}
}
5308
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
