java 基础

针对语句格式2

if(表达式){ ​ 语句1; ​ }else{ ​ 语句2; ​ } ​ if语句格式2的一种嵌套格式

    if(表达式1){
        if(表达式2){
            语句1;
        }else{
            语句2;
        }
    }else{
        if(表达式3){
            语句3;
        }else{
            语句4;
        }
    }

if...else...格式和三元运算符的区别?

    三元运算符只是一个运算符号,不是流程控制语句,在三元中不能输出打印值,
    可以操作具体的数据值(结果最终是数据值);
    而if...else...流程控制语句,范围远远大于三元运算符
    既可以使用具体数据值,也可以是打印内容;
    
    三元运算符能够使用的一定能够if...else...
    if...else...能够实现的,不一定能够使用三元!

if格式3:

if(表达式1){ ​ 语句1; ​ }else if(表达式2){ ​ 语句2; ​ ... ​ }else{ ​ 语句n; ​ } ​ 流程: ​ )先判断表达式1是否成立,成立,则执行语句1 ​ 2)不成立,则判断表达式2是否成立,成立,执行语句2; ​ 否则依次...进行判断 ​ ... ​ 3)如果上面都不成立,则执行else语句,最终结束; ​

场景:针对多种进行判断!

switch语句格式

    switch(表达式){
    case 值1:
            语句1;
            break ;
    case 值2:
            语句2;
            break ;
    ...
    ...
    default:
            语句n;
            break ;
    }

###

1)表达式中的值先和case值1比较,如果匹配,执行语句1,语句break,语句结束; ​ 2)case值1不匹配,继续和case值2进行比较,如果一致,执行语句2,swich结束; ​ ... ​ ... ​ 3)如果上面的case的值和表达式中的结果值都不匹配,执行default语句, ​ 执行语句n,switch语句结束;

    switch语句使用的注意事项:
        1)case语句里面是有break,
            如果没有书写break,会造成"case穿透"
        2)case语句后面的值只能是常量值,不能是变量值
            (Java是一个强类型语言:语法结构很严谨)  
        3)关于default语句   
            它可以在语句中的任何位置,不影响switch语句的执行流程!
            但是如果在语句中,那么break不要省略!(考点)
            如果default语句它在语句的末尾,break可以省略
            
        4)switch语句的结束条件:
                
            1)语句break结束
            2)程序默认执行到末尾!(顺序结构语句都是依次由上而下,末尾结束!)

*/

For语句

    for(初始化语句;条件表达式;控制体语句或步长语句){
        循环体语句;
    }
    
执行流程:
    1)先初始化语句进行赋值
    2)判断条件表达式是否成立,如果成立,执行循环体语句
        2.1)继续执行控制台语句或者步长语句  对初始化语句的变量进行自增或者自减
        2.2)继续判断条件表达是否成立,如果成立,按照上面 这种方式执行;
        2.3)如果变量自增或者自减到条件表达式不成立为止,循环语句结束!

while循环

格式: ​ 基本格式: ​ while(条件表达式){ ​ 循环体语句; ​ 控制体语句或者步长语句; ​ } ​ 扩展格式:(使用多) ​ 初始化语句: ​ while(条件表达式){ ​ 循环体语句; ​ 控制体语句或者步长语句; ​ } ​

执行流程:
    1)初始化语句进行变量赋值
    2)判断条件表达式是否成立,
    成立,执行循环体语句,依次执行控制体语句(对变量控制)
    继续回到2)进行判断
    ...
    ...
    3)条件表达式不满足,循环结束!

while和for的区别?

    共同点:
        都是使用循环思想解决一些问题
    不同点:
        1)格式本身不同
            for(初始化语句;条件表达式;控制体语句){
                循环体语句;
            }
            
            初始化语句;
            while(条件表达式){
                循环体语句;
                控制体语句;
            }
        2)是否明确循环次数
            for循环:明确循环次数优先for循环,(for还是很频繁使用的)
            while循环:不明确循环次数,使用while循环
        3)从内存角度考虑销毁不同:
            for循环结束,里面的变量及时释放了,所以不能在访问for中的变量
            whlile循环结束,依然可以访问里面变量,
            所以消耗资源相对for循环大一些!

*/

常见的两种死循环格式

for(;;){ //jdk源码中比较多 ​ 循环体... ​ } ​

	while(true){ //推荐
		循环体...
	}
	
利用死循环解决一些问题!

死循环:肯定需要利用一些条件,当达到某种条件的时候,结束循环(break;中断,结束!)

\

do-while 循环

格式 ​

    初始化语句;
    do{
        循环体语句;
        控制体语句;
    }while(条件表达式) ;
    
执行流程:
    1)初始化语句进行赋值
    2)循环体语句,--->-完成条件判断---控制体语句
    继续判断,当条件不满足,循环结束!

如果条件直接不满足,循环体至少执行一次; 这也是for/while最大的区别

for循环的嵌套

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

        //循环体---就是内层for循环
        for(初始化语句2;条件表达式2;控制体语句2){
            内层循环的循环体...
        }
    }

//需求 递增星星

/* 打印

* **

---

---

---

    分析:
        定义变量x:行数 ,y,列数(从0开始)
        x=0,第一行, 有1列  y= 0 
        x=1,第二行,有2列  y<=1
        x=2,第三行,有3列 , y<=2  0,1,2
        x=3,第四行,有4列, y<=3  0,1,2,3
        x=4,第五行,有5列, y<=4  0,1,2,3,4
                列数的变化y<=x

*/ class ForForDemo2{ public static void main(String[] args){

    //5行5列的*
    for(int x = 0 ; x <5 ; x++) { //外层控制行数
        for(int y = 0 ; y < 5 ;y++){ //控制列数
            System.out.print("*") ;
        }
        System.out.println() ;
        
    }
    System.out.println("--------------------------") ;
​
    //5行5列,列数在变化
    for(int x = 0 ; x < 5 ; x++){//行数 x=0,0<5 ,1<5
        for(int y = 0 ; y <=x ;y++){//变化的列数  y=0,y<=0 y=0,y<=1
            System.out.print("*") ;     //第一行一个*
        }
        System.out.println() ;//换行
    }
}

}

跳转控制语句:

break ​ continue ​ return ​

break:结束中断的意思

两种应用场景: 1)循环语句中使用,结束循环用的 2)switch语句中使用,结束switch 不能单独使用,不能脱离上面两种场景!

        早期使用:break 标签名称;    结束指定的循环
        
         在for循环嵌套中,给for循环的前面加上一个 "标签名称:"

wc:代表外层循环 nc:代表内层循环

         wc:for(初始化语句;条件表达式;控制体语句){
             nc:for(初始化语句2;条件表达式2;控制体语句2;){
                 //循环体;
                 //当达到我指定的条件,
                 break wc;//结束外层循环了

跳转控制语句之continue

continue:继续执行(结束当前循环,立即进入下一次循环)

return :返回 很少单独去使用(不建议),后面一般都会有返回结果值;

return应用场景:
        在Java中的方法(函数)中去使用,目的就是结束这个方法,并且还有返回结果;
    
        return既然和方法有关系,Java中如何定义方法?

什么是Java中的方法(函数)?

方法:就是一个代码块{},给{}起一个名字(方法名),然后方法中逻辑书写(根据你的实际需求) 以后见到同样一个功能代码块,直接调用方法名即可!

Java中定义方法的格式:

1)有返回值类型的方法的定义 ​ public static 返回值类型 方法名(形式参数类型1 参数名1,形式参数类型2 参数名2...){ ​

        //完成方法的逻辑
        return 结果;
    }
    
    解释上面这个格式
    
        前面固定public static 
        返回值类型:也就是数据类型(现在研究的基本数类型)
        方法名:就是满足标识符的命名规则:见名知意 (小驼峰命名法)
        形式参数类型:也是数据类型(目前:基本数据类型)
        参数名:就是变量名
        
    有返回值类型的方法如何调用呢?
        1)单独调用 ---方法名(实际参数列表) ; (有返回类型的方法不能使用)
        2)输出调用 ---System.out.println(方法名(实际参数列表)) ;
            输出调用:可以,写死了,如果相对结果值在进行操作,就不能用了
        3)赋值调用:(推荐)

public static 返回值类型 方法名(形式参数类型1 参数名1,形式参数类型2 参数名2...){

        //完成方法的逻辑
        return 结果;

在Java中有返回值类型的方法的定义以及调用格式中注意事项:

1)方法和方法平级关系,不能在一个方法中去定义另一个方法! ​ 2)定义方法的返回值类型和main方法中调用方法的时候,接收结果类型不匹配!

    3)Java是强类型语言,在定义的方法时候,
            形式参数名前面必须有参数类型
    4)  必须有return语句,没有就会编译报错!   
    
    5)定义方法的时候,有{号地方不能有分号;有分号;,不能有{左大括号

没有返回值类型的定义格式:

按照正常方法定义(遵循有返回值类型的格式)
public static 返回值类型 方法名(形式参数类型1 参数名1,参数类型2 参数名2...){
    
    方法逻辑体...
    return 结果;

数组定义以及初始化

定义格式: ​

        1)数据类型[] 数组名称;
        2)数据类型  数组名称[] ;
        举例:
            int[] arr;  定义一个int类型的数组arr
            int arr[] ; 定义一个int类型的arr数组
    初始化:
        1)动态初始化
                给定数组长度,系统(jvm)默认分配数组元素内容;

格式: 数据类型[] 数组名称 = new 数据类型[数组长度] ; 数据类型 数组名称[] = new 数据类型[数组长度] ;

                    举例:
                        int[] arr  = new int[3] ;
​
                    在数组如何确定元素的内容
                    数组名称[索引值(角标值)]:从0开始
        2)静态初始化

数组的第二种格式进行初始化:

静态初始化: ​ 给定数组元素,长度由系统给定 ​ 原本格式: ​ 数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ; ​ 数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ; ​

        简写格式
            数据类型[] 数组名称 ={元素1,元素2,元素3....} ;
            数据类型 数组名称[] = {元素1,元素2,元素3....} ;

数组的元素查询表法: 需求: 键盘录入一个数据,输出对应的星期值

分析:
    定义一个字符串数组
    数据类型[] 数组名称=  {元素内容} ;
    String[] strArray =
    {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;

数组的基本元素查找查询数组中元素第一次出现索引值

已知: int[] arr = {25,67,13,66,89,76} ; 需求:查询13第一次出现的索引值; (考虑:查询到了,返回角标;没有没有查询到,也需要返回!)

查询130

方式2:假设思想 1)定义一个 int index = -1; 找不到 2)遍历arr数组,获取到每一个元素 2.1)判断 arr[x] == target,找到了 2.2)修改index的值(重新赋值) index = x ; 2.3)break; 3)循环一圈都没有找到, rturn index ;

定义一个在数组中查询指定元素的第一次出现的索引值 两个明确: 1)明确返回值类型:int 2)明确参数类型以及参数个数 int[]数组, int类型元素(指定的元素),2个 参数

数组高级排序算法之:冒泡排序 思想: 两两比较,将大的值往后方法,第一次比较完毕,最大值出现在最大索引处! */ class BubleSortArrayDemo{ public static void main(String[] args){ //已知一个数组,静态初始化 int[] arr = {24,69,87,54,14} ;

    //排序前:
    System.out.println("排序前:") ;
    //先遍历
    printArray(arr) ;
    
    System.out.println("--------------------------------------------") ;
    
    /*
    //第一次比较
    //将数组的中元素比较
    //arr.length-1:为了防止角标
    //arr.length-1-0:第一次有0个不比
    for(int x = 0 ;x < arr.length-1-0; x++){

面向对象的思想特点 -->基于面向过程

面向过程代表--->C语言
    1)需求分析    --- 键盘录入三个数据,比较数据中最大值---->使用方法完成
    2)定义方法---分析返回值/参数类型/有几个参数
    3)返回结果
    4)自己在main方法测试
    最大特点:
         自己始终执行者
    
举例:生活中的例子
     
​
面向过程
      买电脑
        看配置(喜欢的)---->去赛格电脑城--->砍价还价---->买回来电脑
      洗衣服:
        脏衣服---->找一个盆--->接水--->泡一泡---->搓一搓---->拧一拧----->晾衣服
      买菜
        去菜市场---->砍价/还价---->买菜回来
​
​
面向对象:
      买电脑
        看喜欢的配置---->找一个懂行的朋友---->买回来电脑
      洗衣服:
        脏衣服---->找一个全自动洗衣机---->晾衣服
        
      买菜
        找一个"对象"--->买菜回来
        
            
        
面向对象思想特点:
        1)更符合生活中的思想行为习惯!
        2)让复杂的事情简单化!
        3)让我们从执行者变成指挥者!(角色变化)

面向对象设计理念/特征

不断去创建对象,指挥对象做事情!
​
            //Scanner sc = new Scanner(System.in) ;
面向对象的特征:
    封装
    继承
    多态

将大象装进冰箱 (赵本山说过这样一句话) 面向过程分析

//伪代码
//面向过程:
class Demo{
    public static void main(String[] args){
        open() ;
        in();
        close() ;
    }
    
    //分析:冰箱开的方法
    public static void open(){
        System.out.println("打开冰箱门") ;
    }
    
    //分析:将大象装进去的方法
    public static void in(){
        System.out.println("将大象装进冰箱") ;
    }
    
    //分析:将冰箱门关闭
    public static void close(){
        System.out.println("关闭冰箱门") ;   
    }  
}

将大象装进冰箱(面对对象的方式分析)

//UML:名词提取法:分析:有几个名词---->使用"类"来定义,分析:这个类与哪些功能?
//大象---大象事物-----> class 大象类{}
//冰箱---冰箱事物---->class 冰箱类{}
//Demo类 测试类 (有main方法类)
//伪代码
class Demo{
    public static void main(String[] args){
        
        //使用Java面向对象中创建类对象的格式
        //创建冰箱类对象
        
        //使用冰箱类对象调用开门的方法 open() ;
        //创建大象类对象
       // 使用大象类对象调用in方法  in();
       // 调用冰箱类的关门的方法 close() ;
    }
}
//大象类--->进去的方法
class 大象类{
    
    public static void in(){
        System.out.println("大象进去了") ;
    }
}
​
//冰箱类---->开/关
class 冰箱类{
    public static void open(){
        System.out.println("打开冰箱门") ;
    }
    public static void close(){
        System.out.println("关闭冰箱门");
    }
}
​
​
​
​
​
​
​

类和事物 / ---- 对象/具体事物

类: (是Java中最基本单元)
    类是描述现实世界"事物"的一组"属性"和"行为"的集合!
    
    
    类和事物: 一一对应,相辅相成! 
    一个事务------>定义一个类    
举例:
    学生事物                        -----  > 
                            学生事物 Java代码体现----  定义一个 class Student{}
        属性:年龄,姓名,身高....                         成员变量:位置 类中,方法外  
        行为:学习....                                  
                                                    成员方法(去掉static):和方法定义方法格式一样
                                                             study():学习
                                                             
                                                             
事物:一个类型的总称---描述具体的事物          ----------
​
学生事物                ----->具体事物                       
  属性:姓名,年龄,性别            张三,20,男
  行为:学习                     正在学习JavaEE
  
  
  
  具体事物-----代码中体现--------->创建一个对象
  创建对象的格式:
          类名 对象名 = new 类名() ;
           对象名.成员变量名 = 值; (跟成员变量类型一致); 
           对象名.方法名() ;调用方法,展示这个具体事物有什么功能

需求: 定义一个学生类,描述这个学生事物的属性:姓名,年龄 学生行为:学习 方便打印学生信息--->提供show()展示姓名和年龄

     按上面的需求:进行测试

发现问题:如果在测试类中给年龄赋值非法数据,依然打印;

优化方案1:在学生类中定义一个成员方法(非静态),给年龄赋值(加入逻辑判断) 可以去解决,但是不调用这个方法,依然使用 对象名.age = 非法数据;

方案2: java提供另一种技术 封装 将一个事物的属性私有化(对外界隐藏,private)--->保证数据的安全性 对外提供公共的成员访问方法:setXXX(传参)/getXXX(),来对成员属性进行操作!

        以后在书写 事物(对应的类:手机类/用户类等等,只要描述它的属性和行为)
        成员变量(属性)---->全部私有化!

面试题:(理解并去识记) 局部变量和成员变量的区别?

    区别:
        1)类中的书写位置不同
            成员变量:在类中,方法外
            局部变量:在方法定义中或者方法声明上
        2)jvm内存位置不同
            成员变量:在堆内存中
            局部变量:在栈内存中
        3)生命周期不同:
            成员变量:随着对象的创建而存在,随着对象的创建完毕并且使用完
        等待垃圾回收器回收(不会立即回收)而消失!
            局部变量:随着方法调用而存在,随着方法调用结束而消失
        4)初始化值不同:
            成员变量:存在系统默认初始化,也可以显示初始化
            局部变量:总之:在使用局部变量之前,必须赋值,不赋值不行!

一个类的成员: 成员变量 成员方法(非静态)

  构造方法:
  
    什么是构造方法?
        1)方法名和类名一致
        2)没有具体返回值类型
        3)连void都没有
        
构造方法是可以重载!

构造方法的作用:
        给类的成员进行数据初始化!
        
注意事项:
    1)一个类中,如果没有任何构造方法,那么系统(jvm)自动会给我们提供无参构造方法!
    2)一个类中,只提供有参构造方法,那么系统不会无参构造方法,此时,建议我们永远给出无参构造方法!否则,就出现问题!
    
    创建对象的时候固定格式:
            类名 对象名 =  new 类名() ;