第二周总结

最新推荐文章于 2024-08-10 16:13:20 发布

Sally-lee

最新推荐文章于 2024-08-10 16:13:20 发布

阅读量46

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_47950199/article/details/118854238

版权

(3) : for 语句 (明确循环次数使用)
for的格式:
for(初始化语句;条件表达式;控制体语句;){
循环体语句;
}
for 语句的嵌套:
for(初始化语句;条件表达式;控制提语句){
for(初始化语句;条件表达式;控制体语句){
}
}

(4) : while 语句 (不明确循环次数使用)
while语句的格式:
初始化语句;
while(条件表达式);
循环体语句;
控制体语句;
3.使用的场景不同
(5) : 死循环 break可跳出死循环
死循环的格式有两种:
1. for(;;){
循环体语句;
}
2. while(true){
循环体语句;
}
(6) : do while 循环语句
do while循环语句的格式:
do{
循环体语句;
控制体语句;
}
while(条件表达式);
(7) : for while do while的区别
1.格式的不同
2.for循环节省内存空间:
       for循环结束,变量随着被释放掉,节省内存空间;(不能访问这个变量了.)
       while循环结束,依然可以访问这个变量,比较消耗内存空间...
3.dowhile:优先循环体语句,即使条件不成立,循环体至少执行一次
开发中:
   优先for,其次while,再次do-while
(8) : 跳转控制语句有三个关键字 :
break: 结束中断,结束循环(不能单独使用) 在switch和循环中使用
continue: 继续, 在循环中使用 ,结束当前循环,立即进入下一次循环
return:很少单独使用,结合有具体返回值类型的方法使用! 结束方法的;

看程序:写结果

for(int i = 1; i <= 10; i++) { //i=1,i=2,i=3,i=4,i=5,i=6....i=9
if (i % 3 == 0) {
//在此处填写代码
}
System.out.println("java基础班");

//1)2),3),4)
}
在控制台输出2次“java基础班” break;结束中断
在控制台输出7次“java基础班” continue:结束当前循环,立即进入下一次循环
在控制台输出13次“java基础班” System.out.println("java基础班");

四方法:
方法:就是使用{}代码块包起来,并且起一个名字(见名知意)
Java中定义方法的格式:
1.有具体返回值类型的方法的定义
   固定格式
       public static 返回值类型方法名(小驼峰命名法)(参数类型1 变量名1,参数类型2 变量名2....){
               int a,int b,intc
           ...
               return 结果;

       }

       定义两个数据之和的功能时候,
       两个明确
           1)明确返回值类型:int
           2)明确参数类型以及参数个数
               int类型 2个参数
public static int sum(int a,int b){//形式参数
       int result = a + b;//30+20
       return result ;
}
}

例: class Text {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个值");
int a = sc.nextInt();
System.out.println("请输入第二个值");
int b = sc.nextInt();
System.out.println("请输入第三个值");
int c = sc.nextInt();
int max = sum(a, b, c);
System.out.println(max);
}

public static int sum(int a, int b, int c) {
int max = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
return max;
}
}

方法使用中的注意事项

   1)方法和方法是平级关系,不能进行嵌套: 在一个方法中定义另一个方法不允许

   2)在Java中,定义方法的时候形式参数必须携带数据类型! (Java是一个强类型语言)

   3)调用方法的时候,传递的实际参数不需要在携带数据类型了

   4)定义方法的时候: 有{括号的地方不能有分号;
2. 没有具体返回值的类型的方法的定义:
没有具体返回值类型的方法调用
   1)单独调用: 只能单独调用
   2)输出调用:
   3)赋值调用:

   //void v = printStar() ; //FunctionDemo.java:28: 错误: 非法的表达式开始
   //输出调用
   //System.out.println(printStar()) ; 不行

   //单独调用
   //printStar(m,n) ;
3. 方法重载 :
方法重载(overload) :方法名相同,参数列表不同,与返回值无关!
       参数列表不同:
       1)参数个数不同
       2)参数类型不同
四 : 数组
数组 : 就是存储多个数据的容器,必须保证容器内数据类型的一致.
数组的定义格式:
动态初始化 :
给定了数组的长度,系统默认对元素进行初始化!
数据类型数组名称[] = new 数据类型[数组长度];
数组类型 []数组名称 = new 数据类型[数组长度];
例: int[] arr ;定义一个int类型的数组arr
           int[] arr = new int[3] ;
           int arr[];定义了一个int类型的arr数组
           int arr[] = new int[3] ;
length : 获取数组长度.
静态初始化 :
我们给定的具体的元素,数组长度由系统确定
数据类型数组名称[] = new 数据类型{元素 1, 元素 2, ....};
数据类型 []数组名称 = new 数据类型{元素 1, 元素 2,....};
可简写为 : 数据类型数组名称[] = {元素 1, 元素 2,.... };
数据类型 []数组名称 = {元素 1, 元素 2,....};

遍历 :
printArray2(arr) ; //调用方法
public static void printArray2(int[] arr){
   System.out.print("[") ;
   //遍历数组
   for(int x = 0 ; x < arr.length ; x ++){
       //判断:如果当前x :取到最大索引值 arr.length-1
       if(x==arr.length-1){
           System.out.println(arr[x]+"]") ;
       }else{
           //不是最后一个索引值,中间的元素 arr[x]+", " 不换行
           System.out.print(arr[x]+", ") ;
       }
   }
}
栈:存储都是局部变量(在方法定义中或者方法声明上)
堆:new出来的东西,创建对象 (里面存储:"成员变量")
方法区:有哪些方法--分别存储在哪个类中---xxx.class()

数组的基本应用 :
求最值问题:
class Text {
public static void main(String[]args) {
int[] arr = {69,13,56,87,24} ;
//调用方法
int result = getMax(arr);
System.out.println("数组中的最大值是:" + result);
}
public static int getMax(int[] arr){
//假设思想:
int max = arr[0] ;
for(int x = 1 ; x < arr.length ; x ++){
//判断
if(arr[x] > max){
max = arr[x] ;
}
}
return max ;
}
}

冒泡排序:
class Text {
public static void main(String[] args){
int arr[] = {12,24,6,35,21};
for (int x = 0;x < arr.length-1;x++){
for (int y = 0;y < arr.length-1-x;y++){
if (arr[y] > arr[y+1]){
int a = arr[y];
arr[y] = arr[y+1];
arr[y+1] = a;
}
}
}
sum (arr);
}
public static void sum(int arr[]){
System.out.print("[");
for (int x = 0; x < arr.length;x++){
if (x == arr.length-1){
System.out.print(arr[x]+"]");
}else{
System.out.print(arr[x]+",");
}
}
}
}

方法的形式参数问题 :
形式参数的改变不能影响实际参数


类与对象的关系 :
类 : 能够描述现实世界真实事物的一组属性和行为的集合!
事物 : 现实真是存在的事物;

创建对象 : 格式:类名对象名 = new 类名();

面向对象 :
    面向对象的思想特点:
           1)更符号我们生活中是思想行为习惯
           2)让复杂的事情简单化
           3)我们从执行者变成了指挥者
三大特点 : 封装,继承,多态

成员变量和局部变量的区别 :
1)在程序中的书写位置不同
   局部变量:
       方法定义中或者方法声明上
   成员变量:
       在类中,成员方法外定义的变量
2)在内存中
   局部变量:
           在栈内存中
   成员变量:
           在堆内存中
3)生命周期不同
   局部变量:
           随着方法调用而存在,随着方法调用完毕而消失!
   成员变量:
           随着对象的创建而存在,随着对象创建完毕之后,不会立即消失,
                           需要等待GC(垃圾回收器空闲时候回收掉!)
                                   GC算法----->标记算法
                                               标记---清除
4)初始化不同
   局部变量:
           可以先定义,但是必须在使用之前必须赋值,否则:可能尚未初始化变量
   成员变量:
           可以不初始化,它存在系统默认初始化!(根据类型判定)


如果一个方法的形式参数是引用类型是具体类,那么调用该方法时,实际参数如何传递

//学生类
class Student{
   //有一个成员方法:学习的方法
   public void study(){
       System.out.println("Good Good Study ,Day Day Up!!") ;
   }
}
//定义一个StudentDemo类
class StudentDemo{
   //有一个method成员方法
   public void method(Student s){ //方法的形式参数是Student类型
                                       //调用method 方法的时候:实际参数需要传递的是当前类的具体对象
                                       //Student s = new Student();
       s.study() ;                   //对象名.方法() ;       //stu.study() ;
   }
}
//测试类
class StudentTest{
public static void main(String[] args){
   //在测试类中访问StudentDemo类中的method方法?
   //创建StudentDemo类对象
   StudentDemo sd = new StudentDemo() ;
   //sd.method(s) ;//找不到符号

   //先去创建学生对象
   Student stu = new Student() ;
   sd.method(stu) ;
}
}

匿名对象 :
没有名字的对象
格式:
       new 类名() ;

匿名对象有一个特点:可以作为参数进行传递
           在开发中,匿名对象使用一次即可!
           (因为没有栈内存变量指向堆内存地址,直接是在堆内存开辟空间,使用完毕,立即被回收!)
class NoNameObjectDemo{
public static void main(String[] args){
   //之前的写法
   //访问StudentDemo类中的method 方法
   //创建StudentDemo类对象
   StudentDemo sd = new StudentDemo() ;

   //创建一个具体的学生对象
   Student s = new Student() ;
   sd.method(s) ;

   System.out.println("------------------------------") ;
   //方式2
   StudentDemo sd2 = new StudentDemo() ;
   sd2.method(new Student()) ;
   System.out.println("------------------------------") ;

   //链式编程
   //一步走
   new StudentDemo().method(new Student()) ;
}
}
封装 :
目的 : 保证数据的安全性
private关键字的特点:
       1)可以修饰成员变量,也可以修饰成员方法,但是都只能在本类访问,外界类不能够访问
       2)这些被私有修饰的成员变量,或者成员方法,可以间接通过公共方法来访问!
this :
this:解决局部变量隐藏了成员变量
格式 : this.成员变量名 = 局部变量;
this:就是代表当前类的对象的地址值引用!

构造方法 :
1)构造方法名和类名一致
   2)没有具体的返回值类型
   3)连void都没有
构造方法的目的:为了给类的成员的一些数据进行初始化

无参构造方法 :
private String brand ;
   private int price ;//价格
   private String color ;
public Phone(){
   System.out.println("这是phone类的无参构造方法...") ;
}
....
....
Phone p = new Phone();//
       //setXXX()赋值
       p.setBrand("锤子手机") ;
       p.setPrice(1299) ;
       p.setColor("黑色") ;
       System.out.println("品牌:"+p.getBrand()+",价格:"+p.getPrice()+",颜色:"+p.getColor()) ;
       System.out.println(p) ;
有参构造方法 :
public Student(String name){
   //this.name = name ;
   System.out.println("这是Student类带String类型的有参构造方法...") ;
}
.... (set xxx,get xxx)
....
Phone p2 = new Phone("锤子手机",1299,"黑色") ;
       System.out.println("品牌:"+p2.getBrand()+",价格:"+p2.getPrice()+",颜色:"+p2.getColor()) ;
}
一个类的成员:
           1)成员变量
           2)成员方法
           3)构造方法

Sally-lee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第二周总结

(3) : for 语句 (明确循环次数使用) for的格式: for(初始化语句;条件表达式;控制体语句;){ 循环体语句; } for 语句的嵌套: for(初始化语句;条件表达式;控制提语句){ for(初始化语句;条件表达式;控制体语句){ } } (4) : while 语句 (不明确循环次数使用) whil...
复制链接

扫一扫