Java学习笔记_Week02

发布于:2023-01-28 ⋅ 阅读:(588) ⋅ 点赞:(0)

Week_02学习笔记

一.循环结构

1.for循环

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

2.while循环

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

3.区别

相同点:
都能够体现循环思想,解决代码冗余问题;
不同点:
 1)格式不同
 2)使用场景不同
    明确循环次数优先采用 for循环(普通for循环),实际开发中for使用频次很高,如遍历数组,获取数组中的元素;后期学习增强for循环,主要用于集合中;
  不明确循环次数的则使用while循环.
 3)从内存角度看是否节省内存
    for循环格式较为节省内存资源,当for循环结束,里面的变量就被释放了,这个变量的作用域就在for循环中;
    while循环相对消耗内存,当while结束,依然能够访问变量.   

4.do-while 循环

do{
        循环体语句;
        控制体语句;
}while(条件表达式) ;
//注:do-while循环特点:当条件不成立的时候,循环体语句依旧执行至少一次,实际开发中使用较少.

5.常见死循环

两种格式
格式一:
    for( ; ; ){
            循环体语句;
    }
    
格式二:
    while(ture){
            循环体语句;
    }
    
//注:实际中,while格式死循环使用较常见.利用死循环完成一些逻辑判断需求,当达到某种条件时结束死循环(break;),
例如通过while死循环,通过不断键入数据完成猜数字游戏.

for循环嵌套—for循环的综合运用

格式
for(初始化语句1;条件表达式1;控制体语句1){    //外层循环
     //循环体语句又是一个for循环
    for(初始化语句2;条件表达式2;控制体语句2){    //内层循环
            循环体语句...
    }

}
for循环嵌套的应用

举例: 使用for循环嵌套完成n阶乘法表

import java.util.Scanner;
public class FactorialN {    
    public static void main(String[] args) {             
         Scanner sc = new Scanner(System.in) ;           
         System.out.println("请输入数据n的值:");        
         int n = sc.nextInt();        
         	System.out.println("--------------------");        
         for(int x = 1 ; x<=n ; x++){            
             for(int y = 1 ; y <= x ; y++ ){
             	System.out.print(x+"*"+y+"="+(x*y)+"\t");            
            }            
            	System.out.println();        
         }    
   }
}

二.选择结构

1.if
if语句:
if(关系表达式){
    表达式为true则执行代码
}
if…else语句:
if(关系表达式){
    表达式为true则执行代码1
}else{
    表达式为false则执行代码2
}
if…else if else语句:
 if(关系表达式1){
    表达式1为true则执行代码1
}else  if(关系表达式2){
    表达式2为true则执行代码2
}else  if(关系表达式3){
    表达式3为true则执行代码3
}else {
    以上表达式都不为true则执行代码4
}
if…else嵌套语句
if(关系表达式1){
    if(关系表达式2){
        表达式2为true则执行代码1
    }else {
        表达式2为false则执行代码2
    } 
}else {
     if(关系表达式3){
        表达式3为true则执行代码3
    }else {
        表达式3为false则执行代码4
    } 
}
2.switch
switch语句
switch(表达式或变量名){
    case value1:
        执行语句1;
        break;
    case value2:
        执行语句2;
        break;
    ...
    case valuen:
        执行语句n;
        break;
    default;
        当以上结果都不满足时执行语句n+1;
}
switch语句注意事项
1)switch中的case语句只能是常量
2)switch中的case语句没有携带break,会造成case穿透;
3)switch语句的结束条件:
    a.遇见break结束
    b.程序默认执行到末尾
4)default语句可以在switch语句中任何位置,不影响执行流程
依然当case语句没有匹配的结果,执行default

三.引用数据类型

数组 ,类 ,接口

四.流程控制语句

break
主要用在循环语句和switch语句中,用来跳出整个语句块,终止循环.
continue
用于循环结构中,终止本次循环并立即进入到下一次循环.
return
引入Java中的方法,用来结束方法,
结合有具体返回值的类型的方法使用,必须有结果,否则报错.

五.Java中的方法

1. 方法

给某段代码,使用{}包裹起来,给这个{}起一个名字,就是方法名;在有相同业务逻辑代码,直接使用方法名调用,以提高代码复用性;
注:实际编程中,不能将所有代码都放在main方法中写.

2. 方法定义格式

1).有具体返回值类型
    public static 返回值类型  方法名(形式参数类型1  参数名1,形式参数类型2 参数名2,....){
    代码块;     //完成业务逻辑
    ...
    return  具体结果 ;
    }
2).有具体返回值类型方法的调用格式
    //在main方法中,赋值调用
    
    返回值类型   变量名 = 方法名(实际参数1,实际参数2,...) ;               //实际参数:main方法中键盘录入或直接赋值
3).无具体返回值类型方法及其调用格式
   Java关键字void,代替返回值类型
	定义格式:
	    public static void 方法名(形式参数类型1 参数名称1,形式参数类型2,参数名称2,...){
	        业务逻辑代码块;
	    }
    
    调用格式:
        //单独调用,在main方法中
        方法名(实际参数1,实际参数2,...) ;  

3. 方法重载

overload就是方法重载:为了某个功能能扩展性,多个方法名可以相同(完全相同),参数列表不同,与返回值无关
    public static double getSUM(int x,double y){        
        return x+y ;
    } 
    public static double getSum(double a,int b){        
        double result = a +b; 
        return result ;
    } 
    public static double getSum(int a,double b){        
        double result = a +b; 
        return result ; 
    } 
    public static double getSum(double a,double b){ 
        double result = a +b; 
        return result ; 
    }
    //以上方法名相同,属于方法重载

六.数组

1. 定义

只能存储同一种类型元素的容器

2. 格式

动态初始化和静态初始化
动态初始化:自定义数组的长度,数组的元素由系统(jvm)默认分配;
数据类型[] 数组名称 = new 数组类型[数组长度]

静态初始化:自定义了数组的元素内容,数组长度由系统内默认分配;
数据类型[] 数组对象名 = new 数据类型[]{元素1,元素2,元素3,...}
数据类型 数组对象名[] = new 数据类型[]{元素1,元素2,元素3,...}
简写格式:
数据类型[] 数组对象名 = {元素1,元素2,元素3,...}

注:
数组的特有属性:length
    数组名称.length: 获取数组的长度
    数组名称.length-1: 数组中的最大值索引

3. 数组的基本应用

最值问题:最大值
数组元素查表法:通过数组名称[索引值]确定元素
基本元素查询:查询数组中某个元素的角标值
    弊端:每次查询元素时,都是从头查到尾.
高级数组中的元素查询:二分搜索法(折半查询)

4. JVM内存分配及作用

栈内存:存储局部变量用的这个区域
堆内存:new 出来的对象存储在这个区域
方法区: 
    字节码文件区域 ---- 方法调用过程需要加载类,这些方法被调用,加载进入栈内存
    static区域 ---- main方法就是被static修饰的
    常量池 ---- 常量的存储在常量池
寄存器:本地方法区  底层源码(c语言)

5.基本类型和引用类型分别作为形式参数的特点

基本类型作为形式参数:形式参数改变不影响实际参数;
引用类型作为形式参数:形式参数的改变直接影响实际参数.
实际业务中,用的更多的是"集合"(List,Set,Map),支持长度可变的需求.

6. 冒泡排序的思想以及代码体现

a. 冒泡排序的思想
将数组中元素两两比较,较大值往后放的方法,第一次比较完毕,最大值出现在最大索引值处,以此类推,经过array.length-1次比较,完成由小到大排序.
b. 代码实现
举例: 自定义一个数组或通过键盘录入的方式定义一个数组int[] arr,并将数组由小到大进行排列.
在main方法中通过调用无返回值类型的数组遍历方法 printArray(arr) 和冒泡排序方法 bubbleSort(arr) 来实现数组的遍历和从小到大排列,最后进行打印输出.
    //数组遍历方法
 public static void printArray(int[] arr){                  
       System.out.print(" [");   
      for(int x=0;x< arr.length ;x++){                         
        if(x== arr.length-1){                                                                                 System.out.println(arr[x]+"]");                       
      }else{
               System.out.print(arr[x]+" ,"); 
           }
      }
 }
//定义冒泡排序方法
//方法类型:无返回值 void
//参数类型:数组类型
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[arr.length-1-x]){
                int temp = arr[y];                                     
                arr[y] = arr[arr.length-1-x];                           
                arr[arr.length-1-x] = temp;
               }
        }
    }
}

七.面向对象的编程方法

1. 面向对象的思想特点及特征

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

2. 类

类是描述现实世界事物的一组属性和行为的集合;
Java中体现出来,用代码描述事物:
    class 类名{}         //类名,符合规范:见名知意
    类和事物: 一一对应的关系
    
    例如:
    学生事物                 定义学生类
        属性    -----------   成员变量:类中方法外
        行为    -----------   成员方法:去掉sstatic

3. 封装

权限修饰符 : private
为防止事物属性被修改,出现非法数据;
在描述事物时,需要定义类,类中的所有成员变量(即现实世界中事物的属性),都必须私有化,前面加private
a. 封装
  • 将现实世界事物的属性隐藏了(加入了一个关键字private)
    
  • 私有的,无法直接访问的,保证了对外数据的安全性!(外界不能直接访问)
    
  • 对外提供一个方法,公共的(public)访问方法(setXXX()/getXXX())
    

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

b. private关键字的特点
1)被private修饰的成员变量以及成员方法只能在本类中访问;
2)看可以修饰成员变量也可以修饰成员方法,就是为了外界不能直接访问;
3)被private修饰的成员变量/成员方法可以间接的通过公共的方法访问.
本文含有隐藏内容,请 开通VIP 后查看

网站公告

今日签到

点亮在社区的每一天
去签到