Week2-总结

发布于:2023-01-20 ⋅ 阅读:(20) ⋅ 点赞:(0) ⋅ 评论:(0)

2022/8/1
 

统计思想:

需求: 在控制台输出, 水仙花有多少个?

分析:

  1. 定义一个统计变量count:从0开始

  2. 水仙花:满足3位数,每一个位的数据的立方和相加是这个数据本身
    100-999之间

  3. 确定每各位的数据本身
    int get = 当前这个数据 % 10 ;
    int shi = 当期这个数据/10 %10;
    int bai = 当期这个数据/10 /10 % 10 ;

  4. 判断:x == (ge* ge* ge+shi* shi* shi+bai* bai* bai)
    count ++ ;

  5. 输出count

while循环


  • 格式:
     初始化语句;
    
    while(条件表达式){
           循环体语句 ;
           控制体语句或者步长语句 ;
   }

执行流程:
首先,先初始化语句,对变量赋值;
执行条件表达式,是否成立;成立,则执行循环体语句,依次控制体语句进行变量控制--->再次判断条件表达式是否成立,成立,执行循环体语句--->控制体语句进行变量控制

当条件表达式不成立,while循环结束;

  • 注意事项: 控制体语句不要忘了,否则死循环;

while循环和for循环的区别(重点)

  • 共同点
    能描述一种循环的思想, 将重复性冗余代码进行优化,提供程序阅读性;
  • 不同点

a) 格式不同

b) 场景不同
for循环----明确循环次数(开发中优先使用)
while循环----不明确循环次数

c) 是否节省内存资源
从格式来说
for循环---->循环结束之后, 变量被释放了
while循环--->循环结束,依然可以使用该变量, 相对于for循环格式来说,比较耗费内存资源

实际开发中, for更常使用


2022/8/2

do-while循环

格式:

初始化语句;
 do{
 循环体语句 ; 
 控制体语句 ;
}while(条件表达式) ;

当条件不成立时, 循环体至少使用一次,
jdk源码里面会使用到do-while循环

死循环

两种格式
(一)

for(;;){
 循环体语句;
 }

(二)while格式的死循环----使用更多

while(true){
    
      循环体语句;

break ;
} 

  //当达到某个条件, 结束while循环

Math.random() -----获取一个随机数

流程控制语句

break----结束中断, 在switch 或在循环中
continune----结束当前循环, 立即进入下一次循环
return---在方法中, 结束方法去使用; 一般携带返回的结果, 很少单独使用

方法

定义有具体返回值类型的方法的格式

  • 固定写法:
    public static 返回值类型 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名称2...){
    //完成业务逻辑
    return 结果;
    }
    调用,使用的赋值调用
    返回值类型 变量名= 方法名(实际参数1,实际参数.....) ;

  • 两个明确

  1. 明确返回值类型
  2. 明确参数类型以及参数个数
  • 图解


2022/8/3

方法----没有具体返回值

  • 应用场景
    ① 当某个业务逻辑里面比如完成的数据的直接输出,展示数据----System.out.println("xxx") ;
    ② 业务逻辑中可能数据某个数据在进行排序 数据交换

这种方法在定义的时候, 遵循有具体返回值类型的方法定义格式:
没有具体的结果是直接输出在控制台上,
关键字 void,代替返回值类型(Java定义方法语法的要求:需求没有具体返回结果,就是用void)

  • 定义格式:

     public static void  方法名(形式参数类型1 参数名称1, 形式参数类型2 参数名2,....){
    
    }
    
  • 经典例题:

键盘录入两个数据,比较两个数据是否相等,需要定义方法来实现,并在主方法中测试

方式1:
可以写一个方法,有返回值结果:true/false boolean类型

方式2:
可以写一个方法,没有返回值结果,方法里面直接输出
"两个数据相等" 或者"两个数据不相等"


方法重载 (overload)

方法名相同(完全一致,区分大小写), 参数列表不同(顺序/类型/个数)

方法重载: 为了某个功能扩展性,多个方法方法名可以相同(完全相同),参数列表不同,与返回值无关

  • 参数列表不同
    1)参数个数不同
    2)参数类型不同
    3)考虑参数类型的顺序
    方法重载是概念性的东西,一般用在设计代码层面 ;
    给一个需求,只需要定义某个功能实现即可!后期看jdk的api文档,学习它里面的常用类的一些功能(涉及方法重载)

举例:
公司让你开发针对某个模块的api文档---考虑某个功能,方法的形式参数可以传递任何类型包括引用类型

方法的三种调用形式
直接调用
直接写方法名调用
赋值调用
调用方法,在方法前面定义变量,接受方法的返回值
输出语句调用
只能在有返回值类型的方法调用,直接在输出语句中调用方法 


数组

数组是一种容器,只能存储同种类型的元素, 数组是存储数据的长度固定的容器,可以保存多个数据

特点: 保存的数据类型要一致

注意: 创建数组时, 不能动静结合----不能同时动态和静态初始化,只能有一种

  • 定义格式
    数据类型[] 数组名称 int[] arr
    数据类型 数组名称[] int arr[]

  • 初始化:
    ①动态初始化
    int[] arr = new int[3]
    int arr[] = new int[3]

     ②静态初始化(2种)
      int[] arr = new int[]{元素1,2.... };

       int[] arr = {11,22,33}

长度属性
用数组名.length可以获取数组的长度。因为数组索引是由0开始的,所以数组最大的索引值为数组名.length-1

数组的初始值
数组在没有给其初始化赋值时比如:
int arr=new int[10]
暂且只知道数组长度为10,并没有说明各个索引位的数值是多少。
实际上不同数据类型的数值,在未给其赋值时,都会有一个默认值。

整数类型数组默认值是0
小数类型数组默认值是0.0
字符类型数组默认值是空
布尔类型数组默认值是false
引用数据类型数组默认值是null


数组原理内存图

1.内存的概念
内存是一个很常见的概念,电脑有电脑内存,手机也有手机内存。
内存是程序的临时存储区域,我们编写的程序是存放在硬盘中的,但是在硬盘中到的程序是不会运行的,必须要放进内存中才能运行,运行完毕后会清空内存。
JVM作为Java虚拟机,它要运行程序,自然要对内存进行划分和管理:

  • 寄存器:给CPU使用
  • 本地方法栈:JVM在使用操作系统功能的时候使用
  • 堆内存:存储对象或者数组
  • 方法栈:方法运行时使用的内存;存储局部变量使用该区域
  • 方法区:
    字节码文件区域----方法调用过程需要加载类
    static区域----main方法就是static 修饰的
    常量池----常量都是在常量池

 
数组的变量实际存储的就是堆内存中的地址
只要有new操作就会在堆内存中开辟空间。


2022/8/4


面试题//数组

int[ ] array = new int[3] ;
这句话完成哪些事情? --------内存干了什么事情

1)需要在栈内存中开辟空间, int[ ] array这个变量
2)new int[3] ; 需要在堆内存中申请空间
3)为这个堆内存中的这些数组的元素, 进行系统默认初始化, int类型的元素在数组中默认值0
4)系统初始化完毕, 为堆内存空间产生一个空间地址值,
5)将堆内存空间地址值赋值给栈内存的变量array
6)栈内存变量array指向堆内存地址;


数组中基本应用

①最值问题max/min

分析
假设思想
1.定义一个参照物, array[0] 就是最大值max
2.从array[1]开始遍历数组的其他元素
3.判断: 使用之后的元素一次和参照物进行比较;修改最大值
4.获取最大值

经典例题 int[] array = {65,45,76,87,13} ;

  public class ArrayDemo {
               public static void main(String[] args) {
                                                                          //创建一个数组静态初始化
         int[] array = {65,45,76,87,13} ;

                                                                      //1)定义一个参照物 array[0]
     int max = array[0] ;

                                                               //2)从角标1开始遍历数组的其他元素
    for(int x =1 ;x < array.length ; x++){
                                               
        if(array[x]> max){
                                                       //后面的元素比较大
            max = array[x] ;
        }
    }
    System.out.println("数组中的最大值是:"+max);

    System.out.println("-----------------------------------------") ;

                                                                                //学习了方法,上面代码进行改进
                                                                             //赋值调用
    int max2 = getArrayMax(array) ;                              //实际参数
    System.out.println("max2:"+max2);

    System.out.println("-----------------------------------------") ;

                                                                                //获取数组最小值
    int min = getArrayMin(array);
    System.out.println("min:"+min);
}

②数组查表法

给定一个数据, 快速获取数组中的某个元素 :数组名称[索引值]

//字符串数组---存储字符串

  • String[ ] strArray = { }

//创建数组的格式: 静态初始化

数据类型[ ] 数组名称 = {元素1,元素2,,,,,}

需求 :键盘录入一个数据 : 显示"星期"

public class ArrayDemo2 {

 public static void main(String[] args) {

                                                                         //键盘录入一个数据
    Scanner sc = new Scanner(System.in) ;

                                                                        //提示并录入数据
    System.out.println("请您输入一个数字(0-6):") ;
    int num = sc.nextInt() ;

                                                                    //已知字符串数组--->里面存储 了一些元素
                                                                    
    String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
    
    System.out.println("你查询的星期是:"+strArray[num]) ;
}
 }

数组中的基本元素查找法:

查询元素 的第一次出现的索引值, 每次都需要从头查到尾

对于基本元素查找法的---数组的元素内容, 可以有序/可以无序

二分查找法(折半查找)----数组元素必须有序!

已知一个数组, 静态初始化了, 查询数组中某个元素的索引值:

int[] arr = {}69,57,13,24,87}


查询13这个元素第一次出此案的索引值

//分析
(1)定义一个方法
方法的返回值 int
方法的参数结合参数个数 int[ ] ,2个参数
(2)
遍历数组,获取所有元素
判断: 如果要查询的元素和数组的元素一致, 就找到了返回角标值//

public class ArrayDemo3 {

public static void main(String[] args) {

     
    int[] arr = {69,57,13,24,87} ;

                                                                                       //调用方法
    int index = getIndex(arr, 13);   //找13
    System.out.println("index:"+index);

System.out.println("----------------------------") ;
    int index2 = getIndex(arr, 133);   //找13
    System.out.println("index2:"+index2);

}


public static int getIndex(int[] array,int target){        
                                                                  
    for(int x = 0 ; x < array.length; x++){
                                                                 
        if(target == array[x]){                         
            return  x ;
        }
    }
      return  -1 ;                                        //查询数组:找不到元素,返回负数  -1
}
}

冒泡排序---- bubbleSort(arr) ;

 
两两比较, 将较大的值往后排

规律:
两两比较---将较大值往后放
第一次,有0个不比较
第二次,有1个不比较
.....
比较次数: 数组长度-1----> int x<arr.length-1

 bubbleSort(arr) ;
 
System.out.println("--------------");


public static void bubbleSort(int[] arr){

 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 temp = arr[y] ;
         arr[y] = arr[y+1] ;
         arr[y+1] = temp ;                                 //引入中间变量temp
 }
  }
 }

 }    

2022/8/5

面向对象


2022/8/5

面向对象

创建一个对象的内存图解


/面试题/

  • 形式参数分别为基本类型和引用类型(数组的情况)的不同情况?

基本类型----作为形式参数传递; 形式参数的改变不会影响实际参数
引用类型----作为形式参数传递; 形式参数的改变直接影响实际参数, 除了String类

引用类型String特殊类型: 是一个常量; String 作为形式参数(引用类型), 和基本类型作为形式参数是一样,形式参数的改变不会影响实际参数

(基本类型和引用类型做为形参传递的特点图)
 


/面试题/

  • 局部变量和成员变量的区别?

①局部变量, 在方法定义和方法说明中存在的变量; 其生命周期会随着方法的调用结束
②成员变量, 说明对象的特征特点, 自身特质的变量, 属于程序的默认设置


封装

就是将现实世界事物的属性隐藏了(加入一个关键字private)-----测试类中不能直接使用;
私有的, 无法直接访问的
对外数据的安全性,对外提供了一个方法, 访问权限最小的.
访问方法: setXXX( ) / getXXX( )

XXX-----属性名称, 符合标识符规范

  • 注意事项:

以后在书写的代码的时候,写一个,描述真实存在事物的属性的时候, 需要属性(英文单词字母全部小写)全部加入private


/面试题/

private关键字的特点?

①被private修饰的成员变量及成员方法只能在本类中访问;

class Student{--private--}
class Demo(--无法访问private变量--)

②可以修饰成员变量,也可以修饰成员方法, 就是为了外界不能直接访问

③ 被private修饰的成员变量/成员方法可以间接的通过public方法访问


网站公告

欢迎关注微信公众号

今日签到

点亮在社区的每一天
签到