java_基础2-3

前面我们谈到了一些语言基础和运算基础
java语言基础与运算基础
接下来我们谈一下一些简单语句
if——else 语句

第一种：

if
int a=10;
 if(a>5){
System.out.println("a is big");

第二种

if-else
if(a<5){
System.out.println("a is small");
}
else{
System.out.println("a is big");
}

第三种

if else if else
int m=4;
if(m=1){
System.out.println("一月")
}
else if (m=2){
System.out.println("二月")
}
else if(m=3){
System.out.println("三月“）
}
else if(m=4){
System.out.println("四月")
}

break continue语句

break:结束后面所有语句但是范围在{}中
continue：结束当前循环进入下一次循环
while(){
if() break
}//结束所有此语句不进入下一次循环了
while(){
if()continue;
}//结束当前循环进入下一次循环，不结束当前所有语句

switch语句
语句：

class SwitchDemo2{
public static void main(String[] args){
int a =2;
int season = (a-1)/3;
if(a<1||a>12){
System.out.println("非法月份");
}else{
switch(season){
//多个条件进行罗列
case 0:
  System.out.println("春天");
  //中断switch语句
  break;
  case 1:
  System.out.println("夏天");
  break;
  }
  }
  }

return
返回语句，带着返回值
rerurn+随便一个语句,会出现错误，在return就返回了，后面的语句为不可达代码
除非
if() return;
条件成立时才执行，不成立时仍执行后面的语句；所以return 一般与if连用
循环

while

while(boolean){
.....
}
class WhileDeom1{
 public static void main (String[] args){
 int i=0;
 while(i<10){
 System.out.println(i);
 i++;
 }
 }
 }

注意：while(1){}
死循环，如何让他结束呢
在while(1){
if() break;
}

do_while

do{
System.out.println(i);
i++;
}while(i<10);

//有人这里就有疑问了；不是说do——while 比 while 多一次吗：
小编告诉你：只有进来时条件就不成立时do——while才会多一次；
do_while先语句输出在判断，所以条件第一次输出时条件不影响

给大家出个问题：打印一个直角三角形用“*”，不会的话看下面的代码哦

class TriangleDemo{
public static void main (String[] args){
int n=10;
int i=1;
//行循环
while(i<=10){
//输出整个一行
int j=1;
while(j<=i){
System.out.print("*");
j++;
}
i++;
System.out.println();
		}
	}
}

用循环写9*9乘法表

class NineNine{
public static void main (String[] args){
 int line=9;
 int row=1;
 //行循环
 while(row<=9){
 //列循环
 int col=1;
   while(col<=row){
   System.out.print(col + "x"+ row+"+"+(col*row)+"\t");
   col++;
   }
   System.out.println();
   row++;
   		}
   	}
   }

for 循环

class For{
  public static void main(String[]agrs){
  for(int i=0;i<10;i++){
 System.out.println(i);
 }
 //for 与continue的连用
 for(;;){
 i++;
 if(i%5==0){
 continue;
 }
  else{
  System.out,println(i);}
  		}
  	}
  	//continue;停止当前循环进行下一次循环
break；停止所有

简单语句结束了，接下来来点难得了
函数
定义，特点，应用，重载

调用函数

//编辑好的函数
public static int add(int x,int y)
{
 //int res = x+y;
 return x+y;}
 //后续调用
 int c=add(a,b);
 System.out.println(c);

求函数最大值

//函数
public static int max (int a,int b,int c){
 int max =a>b? a:b;
 max=max>c?max:c;
        return max;}
 //jiecheng
  public static int fabric (int n){
 if(n<=0){
 return -1;
 }
 int res =1;
 for(int i=1;i<=n;i++){
 res = res *i;}
 return res;}

递归

public static int DiGui(int n)
{  if(n==1)
 return 1;
 return n*DiGui(n-1);
}

函数重载overload

//求函数最大值三个
 public static int max (int a,int b,int c){
 int max =a>b? a:b;
 max=max>c?max:c;
        return max;}
//求函数最大值两个
 public static int max (int a,int b){
 int max =a>b? a:b;
        return max;}
  //只有参数的表现形式不同，其他的都一样;
//只有这样系统才能分辨要调用哪个函数
//那参数的类型不同可不可以？
public static int max(double a,int b,int c){
return (int)a+b+c;}
 //是重载

数组

函数格式
修饰符 返回值类型 函数名（类型1，名称1，…){
//函数体
…
return;

//数组
数组：
下标以0位基地址;
 //类型[]变量名=new 类型[]
        int [] fun=new int [10]; 
        //lenth是属性，不是方法不带括号
        System.out.println(fun.;lenth);
//
        System.out.println(a[0]);
//定义的时候直接初始化
     int arr2[]=new int[]{1,2,3}
   数组边界：下标值超过给定的边界值
   索引越界：java.lang.ArrayIndexOutOfBoudsException
//空指针异常java.lang.NullPointerException
  int [] arr3=null;
  System.out.println(arr3.lenth);
  P=&x;//取内存地址——c语言中
  java没有指针——没有显示的指针操作，java中引用就是指针
  指针就是对象的内存地址
  null 对象不存在，不能访问属性方法

null和l数组越界

堆栈
stack：栈
heap：堆
每一个整形占四个字节；

辨别a[o]和null
a[0]，长度是零，只有一个地址，一条线；null连地址都没有，啥都没有;
null 对象不存在，不能访问属性方法
//所以访问时的顺序
int [] arr5=new int [20];
if(ar r== null || arr.length==0)
如果if里面的倒过来：倒过来的话先去访问对象的属性了，结果对象根本不存在，就短路了
所以：先判断空（先判断存不存在在判断里面有没有东西）

for(arr!==null||arr.length>0){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");

注意：

int []arr7=new int[0];
System.out.println(arr[0]);

！一定是错的，就是一个地址一条线，根本没空间存东西；会出现数组越界
数组操作常见问题：
一：提取数组元素的最大值

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

内存结构

二：数组排序（选择排序，冒泡排序）
冒泡排序

//倒着来
class Bubble{
public static void main(String[]args){
 int []arr={3,1,2,5}
 for(i=arr.length-1;i>0;i--){
 for(int j=0;j<i;j++){
 if(arr[j]>arr[j+1]{
int temp=arr[j];
arr[j]=arr[j+1]
arr[j+1]=temp;
}
}
}//迭代打印增强for循环
for(int ii:arr){
System.out.print(ii+" ");
}
}
}

选择排序

for(int i =0;i<arr.length;i++)
 {
  for(int j=i+1;j<arr.length;j++){
  if(arr[i]>a[j})
  {
  int temp;
  temp=arr[i];
  a[i]=a[j];
  a[j]=temp;
	 }
   }
}
//增强for循环
 for(int i:arr){
  System.out.print(i+" ")
       }
   }
}

  

折半查找
折半查找在有序的数列中，进行二分法查找，每次取出搜索范围的中间
值进行比较，依次再进行范围的缩小，直到找到所需要的值
(二分法)找7
1 3 5 7 9
长度5 5/2=2；所以中间的值是arr[2];
五个元素中间的值是5;
第一次全数组查找[0-4]
找到中间数值arr[2]=5;
因为7比5大；所以
第二次寻找[3-4]
3-4的中间值是：（索引的中间值）(3+4)/2;
所以折半查找上去砍一半，然后一直砍
在哪边哪边的值不变
eg：
//1 12 33 44 60 88 97 100；
寻找数字1；
[0-7]–>arr[3]=(44)
[0-2]–>arr[1]=(12)
[0-0]–>arr[0]=(1)
//1 2 3 4 5 6 7 8 9 10
[0-9]->4(5<7)
[5,9]->7(8>7)
[5,6]->5(6<7)
[6,6]-6(7)
最大范围最小范围到一个值
//[0-9]->4(5<7.5)
[5,9]->7(8>7.5)
[5,6]->5(6<7.5)
[6,6]-6(7<7.5)
这样仍不存在的话就可以结束语句了；

lass HalfFind{
  public  static void main(Strng[] args){
 int [] arr={3,5,8,9,12,34,56};
 int min =0;
 int max =arr.length-1;
 int num=8;
 int index = -1;如果找不到就把 -1；输出；
 while(min<=max){
 int mid =(min+max)/2;
        //找到了
 if(arr[mid]==num){
 index =mid;
        break;}
 //范围落在左半边
 else if(arr[mid]>num){
  max=mid-1;
 }//落在右半边
 else{
  min=mid+1;
		  }
	  }
  System.out.println(index)
     
 }
}
 

二维数组

class TwoDimensionArray{
 public static void main(String [] args){
        int no=1;
 for(int i=0;i<arr.length;i++）{
  for(int j=0;j<3;j++){
       arr[i][j]=no;
  no ++;
  }
 }
}
public static void main outArr(int [][] arr){
 for(int i=0;i<arr.length;i++){ 
  for(int j=0;j<arr[i].length;j++){
 System.out.println(arr[i][j]+" ");
 		}
System.out.println();
  }
 }
}

初始化int [] [] arr={{1,2},{2,3},{5,6}};

int [] [] arr={{1},{1,2},{1,2,3},{1,2,3,4}};

       `int [] [] arr2=new int [3][];
       arr2[0]=bew int []{1,2,3};
        arr2[1]=bew int []{4,5,6};
        arr2[2]=bew int []{7,8,9};

三维数组

int [] [] [] arr={
{
   {1,2,3},
   {4,5,6},
   {7.8.9}
   },
   {
   {10,11,12},
   {13,14,15},
   {16,17,18}
   },
   {
   {19,20,21},
   {22,23,24},
   {25,26,27}
   }
   }
   for(int i=0;i<arr.length;i++){
 for(int j=0;j<arr[i].length;j++){
 for(int k=0;k<arr[i][j].length;k++){
  System.out.print(arr[i][j][k]+" ");
  }
          System.out.println();
    }
          System.out.print();
 }