java开发 10.1/10.2/10.3

Day03

一.java三大流程控制

1.顺序控制---依次执行我们的代码;

2.条件控制

         a.目的:对程序执行一直不可预知的流程,进行一个预先判断.

         b.条件:条件具有真假的特性,而且只可能为真,后者为假.

c.java条件控制有四种手段:

(1).if语句

结构:

If(条件){

//实现我们的逻辑

}

(2)if….else语句

结构:

If(条件){

//实现我们的逻辑

}else{

//实现我们的逻辑

}

(3)if(条件)…else if(条件)…(接N个)…else

注意:

         a. else if(条件):条件的约束,和我们前面说的if(条件),两者是等价的.

         b. else if 可以有多个.

         c. else可以省略掉的,但是即使没有匹配所有条件,我们依然建议必须要有else,来保证语句的完整性和可读性.

         d. 如果满足条件只需要执行一行代码,{}也是可以省略的,但是不建议这么做.

(4) switch case

结构:

Switch(判断值){

         Case值1:

         Break;

         Case值2:

         Break;

         …...

         Case值n:

         Break;

         Default:

 

}

条件控制语句彼此可以嵌套使用.

3.表达式的类型:

         Int a = 5;

         a * 3 (结果15)

         表达式的输出类型为表达式计算结果的类型’

------------------------------

double num = 1.5;

num * 4 (6.0,表达式最终被当做的类型就是double类型)

 

练习: 定义一个变量，保存年龄。 并且当年龄大于60岁，我们输出老年. 当年龄在 40 到 60 之间，我们输出中年. 当年龄在18 - 40之间，我们输出少年. 如果小于18岁，输出未成年.

public class DAY{

         publicstatic void main(String[] args){

                   inta = 40;

                   if(a> 60){

                            System.out.println("老年;");

                   }elseif(40<a && a<=60){

                            System.out.println("中年;");

                   }elseif(18<a && a<=40){

                            System.out.println("少年;");

                   }else{

                            System.out.println("未成年;");

                   }       

         }

}

4.循环控制

         a．while 循环

         结构：

         while（循环条件）{

         //循环实现的代码

}

b．do…while循环

结构:

do{

//实现循环的代码

}while(循环的条件);

c. for循环(使用率最高)

结构:

For(循环变量初始化;循环条件判断;循环变量的改变){

//循环需要实现的逻辑

}

d. foreach循环(不是一个常规的java提供的循环方式,他只是java提供的一种语法糖)

foreach:对一种循环方式的命名,常规循环的简化方式.             

语法糖:针对基本的语法,提供了一种简化的实现方式.

补充:

两个关键字:应用到控制循环中,continue的含义是跳出本次循环,break的含义是跳出整个循环.

Continue:

在循环的代码体中，如果遇到continue, 则会跳出当次循环，循环体内continue之后的代码都不会执行，并且循环变量进行一次改变操作，之后再次进行条件判断，如果满足条件，则进入循环，否则直接结束循环;跳出的仅是continue外层直接包裹的循环.

Break:

在循环的代码体中,如果遇到break,则会跳出本循环代码块,break后的代码不会执行.并且整个循环的过程结束.break后退出的循环也是直接包围break的循环.

 

练习: 求1-100自然数，其中所有偶数的和，所有奇数的和，并且求所有偶数的和与所有奇数的和的差.

public class loopdemo2 {

    public static void main(String[] args){

       int a;

       int sum1=0;

       int sum2=0;

       for(a=0;a<=100;a++){

           if(a%2==0){

              sum1=a+sum1;

           }else{

              sum2=a+sum2;

           }

       }

       int differece = sum1-sum2;

       System.out.println("1-100所有偶数的和="+sum1);

       System.out.println("1-100所有奇数的和="+sum2);

       System.out.println("两者之差="+differece);

    }

}

循环的嵌套:

System.out.println(“*”);//输出,会默认换行

Syetem.out,print(“*”);//输出,不会换行

练习: 输出:

*****

****

***

**

*

public class nestingdemo{

    public static void main(String[] args){

    for(int j=1;j<=5;j++){

      

       for(int i=1; i<=(6-j);i++ ){

           System.out.print("*");

       }

       System.out.println("");

    }

    }

}

Day04(数组,方法)

一.数组

New:用来创建一个对象..

1.定义: 用来一次性保存多个相同类型元素的这样一种数据结构.

2.维度上分:一维数组,多维数组.

3.声明:

类型[] 数组变量名称

Int [] arr 或者int arr [];

俩种形式都可以，而且没有任何的区别，不过建议我们采取第一种方式.

4初始化:

数组保存元素的类型[] 数组变量的名称 = new 数组保存元素的类型[元素的数量];

a.动态初始化:

我们在定义一个数组和对数组进行赋值的操作，我们分开来执行。

b.静态初始化:

我们在定义一个数组的同时，进行数组的初始化

                         //动态初始化

                            int[] arr = new int[3];

                           

                            arr[0]= 1;

                            arr[1]= 2;

                            arr[2]= 3;

                           

                            //静态初始化

                            int[]arr1 = new int[]{1,2,3};

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

数组来说，如果初始化一个数组，但是并没有保存任何的值，那么数组中会存放一些默认的值:

byte,short,int,long: 0

float，double:0.0

boolean: false

char: ''

5.length

数组对象中有一个变量length,能够让我们拿到数组的长度.

int a[] = new int[3];

int size = a.length;

数组里面注意事项:

a. 数组长度一旦指定,是永远不可以改变的.

b. 数组保存的元素类型一旦指定,也是不可以改变,并且只能保存该类型的元素.

6.数组元素的访问

arr[index]: index表示数组元素的索引，注意索引是从0到length-1.

arr[1]:访问第二个元素

 

index: 可以是常量,也可以是表达式.

练习:

public class arrdemo1 {

    public static void main(String[] args){

       int[] arr = {1,2,3,4,5,6,7,8,9,10};

       int sum=0;

       double average=0.0;

       int differecesum=0;

       for(int i = 0;i<arr.length-1;i++){

           sum +=arr[i];

           differecesum += (arr[i+1]- arr[i]);

       }

           sum +=arr[arr.length-1];

           average =1.0* sum/arr.length;

           System.out.println("和="+sum);

           System.out.println("平均值="+average);

           System.out.println("两两之差的和="+differecesum);

       

    }

}

二维数组:

1.声明:

类型[][]数组名称;

Int[][] arr;

2.初始化:

a.动态初始化

int [][]arr = newint[3][];

 

b.静态初始化

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

 

length:

这个属性拿到二维数组的长度.

练习:

public classArrayDemo3{

   

    public static void main(String[] args){

           int [][] arr = new int[3][];

          

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

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

      

          

           int [][] arr2 = new int[3][4];

          

           System.out.println(arr2[0][3]);

          

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

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

          

           System.out.println(arr[0][0]);

          

          

    }

   

}

二.方法

定义: 实现一个功能的代码片段的封装。

 

[修饰符...] 返回值类型 方法名称(形参的列表){

         //方法中实现的逻辑

}

 

形参列表: 方法接收外部传入的数据的接收媒介.

返回值: 方法执行结束之后，返回的值的类型.

如果方法不需要返回任何的值，那么我们的方法返回类型写作void.

在方法里返回一个值，需要用到 return.

 

形参列表:

当我们定义了一个方法之后，去调用方法的时候，一定要注意我们传递给方法的入参的类型和数量，一定要一一对应。

 

唯一确定一个方法:

关注点:

a.方法名是否一致

b.形参列表的所有参数类型和数量是否一致. 对于形参变量的命名，完全是没有关系的.

c.返回值的类型

 可以是基本类型,也可以是引用类型.

 

注意:

a.一旦明确指定了方法的返回类型(非void),那么一定要保证最终方法可以成功的返回我们对应的返回类型的数据.

b.关于void返回类型

如果我们不主动的添加return语句，在执行的时候，也会帮我们自动添加return.我们在实现void类型的方法的时候，主动添加一个return也是没有问题.

 

方法参数的传递:

方法参数的传递来说，基本类型传递的是值.对于引用类型，传递的是引用.(传递的是地址)

Day05

 

一. 关于变量的作用域:

 

成员变量: 类的属性

局部变量: 方法中定义的变量或者是方法的形式参数.

 

对于java语言来说，作用域控制是通过块来控制的.

块的概念:一对{} 包裹，该代码片段就称为 一块.

 

对于某个块内定义的变量：

a.对于当前的块，不能再定义同名的变量,即使类型不同也不行。

b.对于当前的块，定义了某个变量，在块外不能够访问到块中定义的变量

 

如果存在块的嵌套:

那么外层块定义的变量，在内层块中是可以访问到的.

 

二. 构造方法(构造器)

 

1.类中特殊的方法，对于定义来讲，它的方法名必须和类名一模一样，并且不返回任何的值，主要不能添加void.

2.在new（创建一个对象的时候），一定会去调用它的构造方法。 但是如果我们没有自己添加自己定义的构造器的话，编译器会帮我们偷偷的添加一个默认的构造器:

  类名(){

 

  }

 

  如果我们主动添加一个默认的构造器，那么在创建对象的时候，通过new 类名(); 会调用我们自己添加的默认构造器.

  3.当我们主动添加了一个包含参数列表的构造器，并且没有主动添加默认的构造器，则再通过new 类名(); 就会遇到编译问题.

 

三. 方法重载 overload

 

1. 对于同名的方法，具有不相同的参数列表，我们在访问的时候，通过调用方法传入不同的参数列表，就可以找到我们特定的方法。

 

2. 当我们定义多个重载的方法的时候，在编译阶段的话，编译器可以根据我们方法形式参数数量以及类型来区别不同的方法，执行阶段可以

   根据我们调用的时候传入的参数列表， 仅仅拥有不同的返回值类型，是不被视为重载的.

  

四. 类的继承

子类继承或者说派生自父类.子类可以享有父类的方法.在初始化一个子类对象的时候，调用其中的方法，如果该方法中在父类也有定义,并且参数列表不同,则调用到的是子类特有的方法.否则调用的是父类方法.

 注意：如果仅仅是他们的返回值类型不同,则会出现编译错误.