java学习第三天

于 2019-09-07 00:10:13 发布
阅读量109 收藏
点赞数
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42326651/article/details/100587038
版权
java打卡第三天，今天的内容有点多，真的希望手别写麻了！想了想今天开始就不以小结来写了，不然内容巨多，然后希望博客写的越来越好！

循环结构

  1. 循环结构的基本组成部分：
    a:初始化；
    b：条件成立，则循环继续，否则，退出；
    c：循环体重复；
    d：步进内容

  2. 三种循环方式：while循环；do-while循环；for循环(最常用

  3. 三种循环的区别
    a：在条件不满足的情况下，while和for循环一次都不执行，但是do-while循环执行一次；
    b：for循环变量在小括号内初始化，只有在循环内部才能使用，while和do-while在括号外初始化，出了循环也可以使用；

for循环

public class Demo09For{
	public static void main(String[] args){
		for(int i=1;i<=100;i++)
			System.out.println("我错了，原谅我吧");
	}
}

while循环(对比于for循环）

public class Demo10While{
	public static void main(String[] args){
		int i=1;
		while(i<=100)
		{
			System.out.println("我错了原谅我吧"+i);
			i++;
		}
		System.out.println("===========================");
		for(int a=1;a<=100;a++)
		System.out.println("我错了，原谅我吧"+a);
	}
}

do-while循环（对比于for循环）

/*1.初始化
2.do{
循环体
步进语句}
while(条件判断);
*/
public class Demo11DoWhile{
	public static void main(String[] args){
		for(int i=1;i<=10;i++)
			System.out.println("原谅你了，起来，地上怪凉的"+i);
		System.out.println("==========================");
		int i=1;
		do{
			System.out.println("原谅你了，起来，地上怪凉的"+i);
			i++;
		}while(i<=10);
	}
}

break 和continue的用法

break的用法：

a：switch语句中，一旦执行，switch语句立刻结束；
b：在循环语句中，一旦执行，立刻跳出该循环，循环立刻结束；

continue的用法：

a：一旦执行，立刻跳过该次循环，剩余循环继续执行；

break实践
public class Demo14Break{
	public static void main(String[] args){
		for(int i=1;i<=10;i++)
		{
		System.out.println("hello!");
		if(i==4)
			break;
		}
	}
}
continue实践
public class Demo15Continue{
	public static void main(String[] args){
		for(int i=1;i<=10;i++)
		{
			if(i==4)
			continue;
			System.out.println(i+"层到了");
		}
	}
}

死循环固定格式（今天刚学的，真香！）

public class Demo16DeadLoop{
	public static void main(String[] args){
		while(true){
			System.out.println("I love JAVA");
		}
	}
}
循环嵌套实践（双循环）
public class Demo17LoopHourAndMinute{
	public static void main(String[] args){
		for(int hour=0;hour<24;hour++)
		{
			for(int minute=0;minute<60;minute++)
				System.out.println(hour+"时"+minute+"分");
		}
	}
}

IDEA的使用（打破了我对eclipse的无上尊崇）

码几个常用的IDEA快捷键
ctrl+Y : 删除该行内容
ctrl+D:复制该行内容
ctrl+alt+L:格式化（强迫症的救星）
ctrl+/：注释
alt+/：代码补全（重要！！！）
alt+Enter:代码纠正

方法的入门到精通

  1. 定义方法的格式
修饰符 返回值类型 方法名称（参数类型 参数名称,...){
方法体；
返回值；
}

< return后面跟的返回值和方法名称与方法定义前的返回值类型保持一致

三种调用方式

  1. 单独调用
  2. 打印调用
  3. 赋值调用

调用流程

a： 传递方法
b：参数传递
c：执行方法体
d：带着返回值返回到调用处
4. 有参数：方法需要一些数据条件，通过小括号将参数传递到方法中
5. 无参数：小括号留空，例如打印
6. 注意事项：
a：方法定义在类中，不能在方法中再定义方法；
b:方法前后顺序无所谓；
c：顶哟后不会执行，若执行，必须调用；
d：在返回值类型不为void情况下，返回值不能省略；
e：return后跟的返回值必须和方法中的返回值类型对应；
f：void方法没有返回值，只能跟return自己；
h：返回值类型为void类型的方法最后一行的return可以省略不写；
I：一个方法可以有多个return语句，但是必须保证只执行一种；

通过方法求和和平均值

package cn.itcast.day04;

//一个方法可以有多个参数，但不能有多个返回值
//如果希望一个方法中产生了多个结果数据进行返回
public class Demo02ArrayReturn {
    public static void main(String[] args) {
        int[] result=calculate( 10,20,40);  //返回的是地址值
        System.out.println(result);
        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }
    }

    public static int[] calculate(int a, int b, int c) {
        int sum = a + b + c;
        int avg = sum / 3;
//        数组可以保存多个结果
//        int[] array=new int[2];
//        array[0]=sum;
//        array[1]=avg;
        int[]  array={sum,avg};
        System.out.println(array);
        return array;
    }

}

通过方法求100以内偶数的和

package cn.itcast.day04.demo03;

public class Demo02MathodSum {
    public static void main(String[] args) {
        System.out.println(getSum());;
    }
    public static int getSum(){
        int num=0;
        for(int i=1;i<=100;i++)
        {
            num+=i;
        }
        return num;
    }
}

方法重载的基本使用

方法重载与下列因素有关
  1. 参数个数不同；
  2. 参数类型不同；
  3. 参数的多类型顺序；
方法重载与下列因素无关

1.参数名称不同；
2.返回值类型不同；

通过方法重载计算未知个数元素的求和
package cn.itcast.day04.demo04;
//方法的重载(Overload),方法名称一样，但是参数列表不一样
public class Demo01MethodOverload {
    public static void main(String[] args) {
//        System.out.println(sumTwo(10,20));
//        System.out.println(sumThree(20,30,40));
//        System.out.println(sumFour(40,50,60,70));
        System.out.println(sum(10,20));
    }
    public static int sum(double x,int y)
    {
        return (int)(x+y);
    }
    public static int sum(int a,int b,int c)
    {
        return a+b*c;
    }
    public static double sum(int a,int b,int c,int d)
    {
        return a+b+c*d;
    }
}
通过方法重载判断两个未知类型数据是否相同
ackage cn.itcast.day04.demo04;

public class Demo02MethodOverloadSame {
    public static void main(String[] args) {
        System.out.println(isSame((short)4000000, (short)40000));
    }

    public static boolean isSame(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    public static boolean isSame(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    public static boolean isSame(long a, long b) {
        System.out.println("long");
        return a == b;
    }

    public static boolean isSame(byte a, byte b) {
        System.out.println("byte");
        return a == b;

    }
}

数组

  1. 数组的概念：一种容器，可以存储多个数据；

  2. 数组的特点：
    a：引用数据类型；
    b：数据当中的多个数据，类型必须统一；

  3. 数组的初始化：在内存建一个数组，并且赋予一些默认值，例如：
    整数：0；
    浮点数：0.0；
    字符类型：’\u0000’;
    字符串类型：null；

  4. 数组元素的初始化：
    a：动态初始化；
    b：静态初始化；

  5. 数组定义的格式：
    数据类型[] 数组名称=new 数据类型[数组长度];

  6. 静态初始化和动态初始化都可拆成两部分，省略格式不能拆分；

  7. 使用建议：
    不确定数组内容：静态初始化；
    确定数组内容：动态初始化；

java的内存划分成五部分

栈（stack）：存放的是方法中的局部变量,方法的运行；
堆：凡是new出来的东西都在堆里，堆中的东西独有默认值；
方法区：存储class相关信息，包含方法信息（死信息）；
本地方法栈：与操作系统有关；
pc（寄存器）：与cpu有关；
索引越界异常
package cn.itcast.day04.demo06;

public class Demo01Arrayindex {
    public static void main(String[] args) {
        int[] array={15,25,35};

        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);

//      ArrayIndexOutOfBoundsException(索引越界异常)
//      原因：索引编号写错了
//      解决方法：修改成为正确的索引编号
        System.out.println(array[3]);
    }
}
求数组最大值
package cn.itcast.day04.demo06;

public class Demo05ArrayMax {
    public static void main(String[] args) {
        int[] array = {5, 15, 30, 20, 10000};

        int max=array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i]>max)
                max=array[i];
        }
        System.out.println(max);
    }

}
数组反转
package cn.itcast.day04.demo06;

import static java.lang.StrictMath.sqrt;

//数组元素的反转
//本来的样子[1,2,3,4]
//现在的样子[4,3,2,1]
public class Demo07ArrayReverse {
    public static void main(String[] args) {
        int[] array = new int[]{1, 4, 2, 5, 6, 7, 8, 9};
        int num = 0;
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        for (int i = 0; i < (array.length - i - 1); i++) {
            num = array[i];
            array[i] = array[array.length - i - 1];
            array[array.length - i - 1] = num;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}
数组作为参数传递
package cn.itcast.day04;
//数组可以作为方法的参数，向方法的小括号传递参数，传的是数组的地址值
public class Demo01ArrayParam {
    public static void main(String[] args) {
        int[] array={10,20,30,40,50};
        printArray(array);   //传递进去的是array保存的地址值
        System.out.println("=================");
        printArray(array);
        System.out.println("===========");
        printArray(array);
    }

    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}
塔克拉玛干的咸鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值