选择结构 分支结构 循环结构 方法 数组 面向对象 关键字

---

前言

选择结构的概念、if语句、if else语句、switch分支语句、局部变量的概念

---

一、选择结构与分支结构

概念：
根据已知条件‘进行逻辑判断，满足条件后执行相应操作;

1.1基本if选择结构

语法：

if(布尔表达式){
//代码块
}
//后续代码.....

执行流程：
对布尔表达式进行判断；
结果为true，则先执行代码块，再执行后续代码；
结果为false，则跳过代码块，直接执行后续代码；

1.2if else选择结构

语法：

if(布尔表达式){
 //代码块1
}else{
 //代码块2
}

执行流程：
对布尔表达式进行判断；
结果为true，则先执行代码块1，再退出整个结构，执行后续代码；
结构为false，则先执行代码块2，再退出整个结构，执行后续代码；

1.3多重if选择结构

语法：

if(布尔表达式1){
//代码块1
}else if(布尔表达式2){
//代码块2
}else if(布尔表达式3){
//代码块3
}else{
//代码块4
}

执行流程：
表达式1为true时，则执行代码块1，再退出整个结构；
表达式2为true时，则执行代码块2，再退出整个结构；
表达式3为true时，则执行代码块3，再退出整个结构；
以上均为false时，则执行代码块4，再退出整个结构；
注意：
相互排斥，有一个为true，其它均不再执行，适用于区间判断（区间条件，遵循从大到小或从小到大）；

1.4嵌套if选择结构

语法：

if(外层表达式){
 if(内层表达式){
  //内层代码块1
 }else{
  //内层代码块2
 }
}else{
//外层代码块
}

执行流程：
当外层条件满足时，再判断内层条件；
注意：
一个选择结构中，可以嵌套另一个选择结构；
嵌套格式正确的情况下，支持任意组合；

举例

需求:
*          键盘录入三个数据,求最大值(int类型)
*
*         两种方案
*          1)使用三元运算符去完成
*          2)使用if格式2的嵌套

import  java.util.Scanner ;
public class IfTest2 {
    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() ;
         //方案1:
        //三元运输符 (表达式)? 执行true的结果:执行false的结果
        //使用中间变量
        int temp = (a> b) ? a: b ;
        //定义结果变量
        int max = (temp > c)? temp :c ;
        System.out.println ("三个数据中的最大值是:"+max) ;

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

        //方式2:if格式2的嵌套 (不推荐的)
        //定义变量max2
        int max2 ;
        if(a > b){
            //使用a和c进行对比
            if(a> c){
               max2 = a ;
            }else{
               max2 = c ;
            }

        }else {
            //b大
            if(b > c){
                max2 = b ;
            }else{
                max2 = c ;
            }

        }

        System.out.println("三个数据中的最大值是:"+max2) ;

    }
}

1.5switch分支结构

语法：

switch(变量|表达式){
 case  值1:
  逻辑代码1;
 case  值2:
  逻辑代码2;
 case  值n:
  逻辑代码n;
 default:
  未满足时的逻辑代码;
}

可判断的类型：
byte、short、int、char、String(JDK7+)
执行流程：
如果变量中的值等于值1，则执行逻辑代码1；
如果变量中的值等于值2，则执行逻辑代码2；
如果变量中的值等与值n，则执行逻辑代码n；
如果变量中的值没有匹配的case值时，执行default中的逻辑代码；

注意：

所有case的取值不可相同；

程序演示：

import  java.util.Scanner  ;
public class SwitchDemo {

    public static void main(String[] args){

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

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

         switch (week){

            case 1 :
                System.out.println("星期一");
                break ;
            case 2 :
                System.out.println("星期二");
                break ;
            case 3 :
                System.out.println("星期三");
                break ;
            case 4 :
                System.out.println("星期四");
                break ;
            case 5 :
                System.out.println("星期五");
                break ;
            case 6 :
                System.out.println("星期六");
                break ;
            case 7 :
                System.out.println("星期日");
                break ;
            default:
                System.out.println("您输入的数据不合法");
                break ;

        }


    }
}

注意：
当匹配的case被执行后，并不会自动退出整个结构，而是继续向下执行；
break关键字可以在匹配的case执行后，直接跳出整个结构；

二、循环结构

2.1for循环语句

基本格式：

for(初始化语句;条件判断语句;步长语句(控制体语句)){

      循环体语句;
  }
   流程:
  1)先执行初始化语句对变量进行赋值(只执行一次)
  2)判断条件语句是否成立,如果成立,执行  循环体语句
  3)执行步长语句(++,--)
  4)继续判断条件是否成立,如果还成立, 执行  循环体语句
  5)继续执行步长语句(++,--)
  ...
  ...
  n)当前条件不成立,for循环结束

举例

需求:
*  1)控制台输出1-10之间的数据
*  2)求出1-10之间和
*  3)1-100之间的数据之和

public class ForDemo {
    public static void main(String[] args){
for(int x = 1 ; x <= 10 ; x ++){
    System.out.println(x) ;
       }
//1-10之间的数据获取
int sum = 0 ;
for(int x = 1 ; x <= 10 ; x ++){
   sum += x ; //sum = sum + x ;

      }
System.out.println("1-10之间的数据和是:"+sum);
  }
}

2.2while循环语句

基本格式

  while(条件表达式){
          循环体语句;
          控制体/步长语句;
      }

扩展格式：

初始化语句;
while(条件判断语句){
循环体语句;
控制体/步长语句;
}

流程:
初始化语句执行一次
判断条件是否成立,成立,则执行循环体,再依次执行步长语句;
…
如果不成立,while循环语句结束!

举例

//需求:键盘不断录入数据,玩猜数字小游戏! (1-100之间的数据)

//分析:
//1)使用Math类的 random方法产生一个1-100之间的随机数 (要猜的数据)
//2)创建键盘录入对象,录入数据
//3)录入的数据和当前产生的随机数据的进行比较,
//4)如果大了,提示大了
//小了,提示小了
//相等,猜中了

//break:switch语句中,循环语句中使用

//产生一个1-100之间的随机数
int num = (int)(Math.random()*100+1) ;

while(true){
    //导包
    //创建键盘录入对象
    Scanner sc = new Scanner(System.in) ;

    //提示并录入数据
    System.out.println("请您输入1-100之间的数字:") ;
    int guessNumber = sc.nextInt() ;

    if(guessNumber> num){
        System.out.println("您要猜的数字大了!");
    }else if(guessNumber < num){
        System.out.println("您要猜的数字小了!") ;
    }else{
        System.out.println("恭喜您,猜中了!") ;
        break ; //中断循环,否则死循环...
    }

}

需求:
*     输出所有的水仙花数
*     统计所有的水仙花数

public class WhileDemo {

    public static void main(String[] args){
     //输出所有的水仙花数
        //初始化语句
        int j = 100 ;
        while(j<1000){
            //定义三个变量:ge shi bai
            int ge = j % 10 ;
            int shi = j /10 % 10 ;
            int bai = j /10 /10 % 10 ;

            if(j == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                //输出
                System.out.println(j)  ;
             }

            j ++ ;
        }


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

        //统计水仙花
        //定义统计变量
        int count = 0 ;
        //初始化语句
        int i = 100 ;
        while(i<=999){

            //定义三个变量:ge shi bai
            int ge = i % 10 ;
            int shi = i /10 % 10 ;
            int bai = i /10 /10 % 10 ;

            if(i == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                //统计变量++
                count ++ ;
            }

            //步长语句
            i ++;

        }

        System.out.println("水仙花是共有:"+count+"个");


    }
}

2.3while和for的区别

1)格式不同
2) 并且从内存角度考虑:
for循环的 格式: for循环语句外面不能够访问变量的,因为它随着for循环执行完毕,main方法结束之后,变量就会被GC(垃圾回收器)回收掉这些变量
while循环的扩展格式:循环结束,依然可以访问变量; 在内存中占用资源空间大于for循环
3)如果明确循环次数,优先使用for
不明确循环次数,使用while循环

2.4do-while循环

基本格式：

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

流程:
初始化语句执行一次,对变量进行赋值
执行循环体语句,
执行步长语句(++或者–)
判断while后的条件是否成立,成立,继续执行循环体语句…
不成立,语句结束!

do-while循环和for循环以及while循环的最大的区别就是:循环体至少执行一次!

举例

public class DoWhileDemo {
    public static void main(String[] args){

        //控制台输出5次"helloworld"
       // int i = 1 ;
        int i = 6 ;
        do{
            System.out.println("helloworld") ;
            i++;
        }while(i<=5) ;
    }
}

2.5forfor循环嵌套

格式：

for循环嵌套
      for(初始化语句;条件表达式;步长语句){

          //内层循环是外层循环的循环体语句
          for(初始化语句;条件表达式;步长语句){
                  循环体语句;

          }
      }

注意：
将内层循环看成是外层循环的循环体语句;

举例

需求:
  控制台输出*形(4行5列的*)
      *****
      *****
      *****
      *****
public class ForForDemo {
    public static void main(String[] args){
  for(int x = 0; x < 4 ; x ++ ){//x =0 ,1,2,3  //控制行数

            for(int y = 0 ; y < 5; y++){//y =0,1,2,3,4 //控制列数
                System.out.print("*") ;
            }
            System.out.println() ;
        }



    }
}

三、方法

3.1如何定义一个方法

3.1.1有具体返回值(数据类型)的方法

                                                //  形式参数列表
权限修饰符 + 静态修饰符 + 具体的返回值类型 + 方法名(数据类型1 变量名1 ,
数据类型2 变量名2 ,....){
              //方法体
              return 结果;
        }              

3.1.2没有具体返回值类型的方法

*          权限修饰符+静态修饰符+返回值类型 +方法名(形参列表){
*                       没有return 语句 ;
*                       直接完成输出操作
*
*          }

定义方法有两个明确:
1.明确放回值类型
2.明确参数类型和个数

3.2如何调用方法

调用方法:
1)单独调用:(没有输出)没有意义
2)输出调用:输出:写死了,不利于值的进一步操作
3)赋值调用(推荐)

3.3方法的重载

概念：
多个方法的方法名相同,参数列表不同,与返回值无关 —将这些方法称为"方法重载"
参数列表不同有两种情况
1)参数个数不同 (参数类型一致)
2)参数类型不一致(参数个数一致)

         public static float sum(float a,float b) {}
         public static float sum(int a,float b){}
         public static int  sum(int a,int b){}
         public static double sum(double a,double b,double c)
         public static int add(int a,float b)
         public static int add(float a ,int b)

四、数组

4.1数组概述

数组概念
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
数组定义的格式

格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];

4.2数组的初始化

数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式：
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
动态初始化
动态初始化初始化时只指定数组长度，由系统为数组分配初始值
格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。

int[] arr = new int[3];

解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

静态初始化
静态初始化初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法
int[] arr = {1,2,3};

遍历数组

//给int[]a={15,20,25,56,78,89,65};进行遍历,格式优雅
public class Demo {
    public static void main(String[] args){
        int[] a={15,20,25,56,78,89,65};
        System.out.print("[");//先输出左中括号"["不换行
         //将元素的内容先获取到
        for(int i=0;i<a.length;i++){ //i:数组中角标值(索引值)
            //需要判断元素是否为最后一个
            if (i==a.length-1){// 如果是最大角标值 a.length-1
                System.out.println(a[i]+"]");
            }else{//表示是中间的元素,拼接逗号和空格,不能换行
                System.out.print(a[i]+", ");
            }
        }
    }
}
## 求数组的最值问题```

```java
//定义一个数组,静态初始化 int[] arr = {12,87,69,24,65};
//使用方法得到最值
public class Demo1 {
   public static  void main(String[] args){
       int[] arr = {12,87,69,24,65};
       int max = max(arr);
        System.out.println("最大值是:"+max);
        System.out.println("---------------------");
       int min = min(arr);
       System.out.println("最小值是:"+min);

   }
    public static int max(int arr[]){
       int max=arr[0];
       for(int i=1;i<arr.length;i++){
           if(arr[i]>max){
            max = arr[i];
           }
       }
       return max;
    }
    public static int min(int arr[]){
        int min=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]<min){
                min = arr[i];
            }
        }
        return min;
    }

}

数组的逆序

//给定一个数组，把这个数组中所有元素顺序进行颠倒。（静态初始化）int arr[]={66,78,95,5,68,105}
public class test2 {
    public static  void main(String[] args){
        int arr[]={66,78,95,5,68,105};

        System.out.println("逆序前:");
        zx(arr);
        System.out.println("逆序后:");
        nx(arr);
        zx(arr);

    }
    public static void zx(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]+", ");
            }
        }
    }
    public static void nx(int arr[]){
        for (int start=0,end =arr.length-1;start<end;start++,end--){
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }
}

查询数组索引值

//int[] arr = {10,55,30,24,17} ;查询30这个元素第一次在数组中出现的索引,查询元素使用功能完成!
public class test4 {
    public static void main(String[] args){
        int[] arr = {10,55,30,24,17} ;
        int key=jb(arr,17);
        System.out.println("角标是:"+key);

    }
    public static int jb(int arr[],int key){
        for(int x =0;x<arr.length;x++){
            if (key == arr[x]){
                return x;

            }
        }
        return -1;
    }
}

数组之冒泡排序

public class tset1 {
    public static void main(String[] args){
    int arr[]={78,56,13,98,105};

        System.out.println("排序前:");
        bl(arr);//遍历
        System.out.println("排序后:");
        maopao(arr);//调用方法来排序
        bl(arr);//遍历
    }
   

    public static void maopao(int arr[]){
        for (int x=0;x<arr.length-1;x++){//0,1,2,3循环的次数
            for (int y=0;y<arr.length-1-x;y++){//y是角标0,1,2,3,4
                if(arr[y]>arr[y+1]){//判断:如果前面的元素比后面元素大,将大的元素往后放
                    int temp=arr[y];//交互元素----采用中间变量的方法
                    arr[y]=arr[y+1];
                    arr[y+1]=temp;
                }


            }
        }
    }
    //遍历数组
    public static void bl(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]+", ");
            }

        }
    }
}

五、面向对象

面向对象思想概述以及特点
思想概述:
面向对象是基于面向过程的编程思想
特点：
1.是一种更符合我们思想习惯的思想
2. 可以将复杂的事情简单化
3. 将我们从执行者变成了指挥者角色发生了转换
Java语言的面向对象特征:
封装(encapsulation) 继承(inheritance) 多态(polymorphism)

5.1类与对象关系

类：是一组相关的属性和行为的集合
类—Java中的最基本单元

对象：是该类事物的具体体现(应该是指定的某个类中具体的事物)
类的定义
例如：现实世界的事物 属性 人的身高，体重等 行为 人可以学习，吃饭等Java中用class描述事物也是如此

成员变量: 就是事物的属性

成员方法: 就是事物的行为 定义类其实就是定义类的成员(成员变量和成员方法)

格式

class Student{
        //定义成员变量 (学生事物的属性)
        //定义成员方法(学生事物的行为)

    }

    //测试类中

        对象:描述具体事物
        创建对象的格式:
        类名 对象名 = new 类名() ;
        Student s = new Student() ;

        //给学生赋值:姓名,年龄,身高,性别
        对象名称.成员变量= 赋值;
        //使用学生的行为:访问成员方法
        对象名.方法名() ;
    

定义学生类（举例）

//学生有姓名,年龄,性别属性,行为有学习,睡觉以及玩游戏的行为,请使用面向对象方式书写学生类并且进行测试
//定义一个学生类
class Student{
    //定义成员变量
    String name;
    int age;
    String sex;
    //定义行为方法
    public void study(){System.out.println("正在学习!!");}
    public void sleep(){System.out.println("晚上要睡觉");}
    public void game(String gameName){System.out.println("睡前打"+gameName+"两小时");}
}



//测试区
public class studentTest {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        //给成员变量赋值
        s.name="朴振龙";
        s.age=21;
        s.sex="男";
        System.out.println("学生名字叫:"+s.name+",年龄是:"+s.age+"性别:"+s.sex);
        s.study();
        s.game("lol");
        s.sleep();
    }
}

5.2匿名对象

匿名对象：就是没有名字的对象。
是对象的一种简化表示形式
匿名对象的两种使用情况
对象调用方法仅仅一次的时候
作为实际参数传递

格式

  new  类名() ;
       new 类名().成员方法名() ; 访问当前类中的成员方法
//1:new Student().show();
//2:new StudentTest().method(new StudentDemo());

类名 对象名 = new 类型() ; 有名字的对象
特点:
1.匿名对象:使用完毕,会立即垃圾回收器回收,节省内存空间!
应用场景:都是在移动端使用居多—Android :基于Java (大部分都是使用匿名对象,节省内存)
2.开发中,匿名对象使用一次即可,不要使用多次! (使用完毕,就立即被回收)
3.匿名对象可以作为参数传递

5.3封装

Java提供一个关键字:private 封装
封装概述:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。

六、关键字

6.1private关键字

private关键字：
是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。
private最常见的应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用\

6.2this关键字

this:代表所在类的对象引用
记住：
方法被哪个对象调用，this就代表那个对象
什么时候使用this呢?
局部变量隐藏成员变量

举例

/*
* 将下面的需求写完后进行测试！
	编写一个矩形类Rect，包含：
	矩形的宽width；矩形的高height。
	两个构造方法：
		一个带有两个参数的构造方法，用于将width和height属性初化；
		一个不带参数的构造方法，将矩形初始化为宽和高都为10。
	两个方法：
		求矩形面积的方法area()
		求矩形周长的方法perimeter()
*
* */

//创建一个矩形类
class Rect{
    //定义成员变量,并封装private
    private int width;
    private int height;
    public void setWidth(int width){
        this.width=width;
    }
    public int getWidth(){
        return width;
    }
    public void setHeight(int height){
        this.height=height;
    }
    public int getHeight(){
        return height;
    }
    //定义构造方法
    public Rect(){//无参数构造

    }
    public Rect(int width,int height){//有参数构造方法
        this.width=width;
        this.height=height;
    }

    //创建成员方法
    public  int mainji(int width,int height){//计算面积
        return width*height;
    }
    public  int zhouchang(int width,int height){//计算周长
        return (width+height)*2;
    }

}







//矩形方法测试区
public class RectTest {
    public static void main(String[] args){
        Rect r=new Rect(10,10);//创建一个矩形对象


       int a= r.mainji(r.getWidth(),r.getHeight());//调用方法算面积
        System.out.println("矩形的面积是:"+a);//输出
        int b=r.zhouchang(r.getWidth(),r.getHeight());//调用方法算周长
        System.out.println("矩形的周长是:"+b);//输出周长

    }
}