• class TT_1{ public static void main(String[] args) { //String str_1 = "wawa";//这是一个字符串 //String str_2 = "wawa";//这是一个字符串 //boolean result_1 = (str_1 == str_2); //System.out.println(

    展开全文
  • java学习心得第7天(循环结构) 通过一天的java学习,在千锋教育老师的讲解下,让我对java这门语言有了更深层次的了解。今天学习的是java当中的循环结构,下面我总结一下今天学习的内容: 一、什么是循环结构? 循环...

    java学习心得—循环结构

    通过对java循环操作的学习,在千锋教育老师的讲解下,让我对java这门语言有了更深层次的了解。下面我总结一下今天学习的内容:

    一、什么是循环结构?

    循环结构是通过某个条件,重复的执行一段逻辑代码。
    在这里插入图片描述

    二、循环结构包括什么?循环操作需要什么条件?是否使用循环及使用步骤!

    1目前学习到的java循环结构有while、do-while和for循环。

    2如需要一个明确的循环组成有四个必要条件:

    (1)初始部分:用来设置循环的初始变量。
    (2)循环条件:决定是否继续循环的依据。
    (3)循环操作:单次执行的逻辑代码或者任务。
    (4)迭代部分:控制循环条件改变的增量(缺少将会产生死循环)。

    3是否使用循环及使用步骤:

    (1)拿到一道题或者一个任务一定要先明确是否需要使用循环。
    (2)分析循环条件和循环操作是什么。
    (3)循环结构的选型。(while、do-while、for循环)

    (一)while循环

    1.while循环的语法:

    while(布尔表达式){
    //逻辑代码
    }
    在这里插入图片描述111

    2.执行流程:

    (1)先对布尔表达式进行判断,结果为ture则执行逻辑代码。
    (2)本次执行完毕后,再进行判断,结果仍旧为ture式,循环会再次执行。
    (3)直到布尔表达式的结果为false时,退出循环结构执行后续代码。

    3.while循环的特点:

    (1)如果首次判断不满足条件,则一次都不会执行。(执行次数:0~n次)。
    (2)先判断,再执行。适用于循环次数明确的情况。

    (二)do-while循环

    1.do-while循环的语法:

    do{
    //逻辑代码
    }while(布尔表达式)
    在这里插入图片描述

    2.执行流程:

    (1)先执行一次循环操作,再进行布尔表达式的判断。
    (2)如果结果为ture,则再次执行循环操作,如果结果为false,才会退出循环,执行后续代码。

    3.do-while循环的特点:

    首次不判断条件是否满足,先执行一次,再进行判断。

    (三)for循环

    1.for循环的语法:

    for(初始部分;循环条件;迭代部分){
    //循环操作
    }
    在这里插入图片描述

    2.执行流程:

    (1)首次执行初始部分(仅一次)。
    (2)对布尔表达式进行判断,结果为ture时,则会执行逻辑代码。
    (3)本次执行完毕后,执行迭代部分,迭代部分执行完以后再次进行判断,结果仍旧为ture,则再次执行逻辑代码。
    (4)直至布尔表达式的结果为false时,才会退出循环结构,执行后续代码。

    3.while循环的特点:

    (1)for循环和while循环相同,如果首次判断不满足条件,则一次都不会执行。(执行次数:0~n次)。
    (2)先判断,再执行。适用于循环次数明确的情况。

    (四)嵌套循环

    概念

    在一个完整的循环结构中,嵌套另一个完整的循环结构。(注意:各循环可互相嵌套,且一般不超过三层)
    嵌套循环的外层控制行数,内层控制列数。外层循环变量变化一次,内层循环变量变化一轮。

    如:打印一个等腰三角形

    在这里插入图片描述

    如:打印一个乘法表

    在这里插入图片描述

    三、流程的控制

    目前学习到的流程控制有两个:1.break,2.continue。

    1.break

    break:终止、跳出 switch分支结构和循环结构。

    2.continue

    continue:结束本次循环,进入下一次循环。循环执行中遇到continue则会跳出此次循环,进入下一次循环。

    四、比较while、do-while、for

    while:先判断、再执行。 如果不成立就不会循环。
    do-while:先执行、再判断。 不管条件是否成立都进行一次循环(至少执行一次)。
    for:需要的条件与while相同,但for循环的写法更为简洁。

    展开全文
  • Java基础学习心得体会

    2020-01-12 08:59:07
    Java基础学习心得体会基础 变量:程序运行期间,值可以发生变化的量;把变量理解为容器; java的执行过程从上到下,从左到右。 运算符: 1.赋值运算符 = 2.算数运算符 + - * / % ++ – 3.比较运算符> < == ...

    Java基础学习心得体会

    变量:程序运行期间,值可以发生变化的量;把变量理解为容器;
    java的执行过程从上到下,从左到右。
    运算符:
    1.赋值运算符 =
    2.算数运算符 + - * / % ++ –
    3.比较运算符> < == != >= <=
    4.复合运算符+= -= *= /= %=
    5.逻辑运算符&& || !
    6.条件运算符 ? :

    运算符的使用注意

    1. 赋值运算符;
      赋值号 从后向前翻译
      int m=8*7;
    2. 算数运算符;
    		int m=10;
    		int n=21;
    		System.out.println(m+n);
    		System.out.println(m%n);
    		System.out.println(m/n);
    		System.out.println(n%m);
    		System.out.println(n/m);
    		System.out.println(m++);//先执行语句 后自增
    		//m++;++m;此情况 自增都会执行
    		/*
    		 * 如果除了自增还有其他代码需要执行,那么++在前就先自增后执行语句;
    		 * 如果++在后,就先执行语句,后自增;
    		 * --同上
    		 * */
    

    3.比较运算符 返回值 boolean

    		int m=18;
    		int 	n=28;
    		boolean result= m>n;
    		System.out.println(result);
    		System.out.println(m == n);
    		System.out.println(m!=n);
    
    1. 复合运算符
    		//问题:/ % -		
    		//a1=2-a1;
    		//以下才可以简写
    //		a1= a1-2;
    //		a1-=2;
    		
    //		a1=a1/2;
    //		a1/=2;
    
    1. 逻辑运算符
      &&:要求运算符两边的条件同时为真,结果才为真!
      ||:只要两边任意一个为真,结果即为真!
      !:对结果取反!
    		int age=18;
    		int money=10;
    		System.out.println(age>=18 && money>=5);
    		System.out.println(true && age>1);
    		System.out.println(false || money>5);
    		System.out.println(!(false||true));
    
    1. 条件运算符 ? :
      规则: boolean值 ? 值1:值2;
      如果boolean为true,就取走值1;如果为false,就取走值2;
    //求三个数中的最小数
    		int x=44;
    		int y=66;
    		int z=88;
    		int min=(x<y?x:y)<z?(x<y?x:y):z;
    		System.out.println(min);
    

    循环语句

    for循环语句

    			//公约数
    			int n=12;
            	int m=18;
            	int num=0;
            	for(int i=1;i<(n<m?n:m);i++) {
            		if(n%i==0&&m%i==0) {
            			num=i;
            		}
            	}
            	System.out.println(num);
            	//公倍数
            	for(int j=n>m?n:m;j<=m*n;j++) {
            		if(j%n==0&&j%m==0) {
            			System.out.println(j);
            			break;
            		}
            	}
    

    do…while 不管条件是否成立 循环体先走一次

     int	a = 10;
    			do {
    				System.out.println("撸啦啦啦啦");
    			}while(a < 9);
    			//do..while 不管条件是否成立  循环体先走一次
    

    while 未知的循环次数

    		long money=1000000000;//一个亿
    		int count=0;
    		while(money>0) {
    			money/=2;
    			count++;
    		}
    		System.out.println(count);
    

    break 结束离 其最近的一层循环
    continue 跳过本次循环 继续下一次

    条件语句

    switch… case语句

    		//练习:输入年月日,判断此日期是当年的第几天
    		System.out.println("输入月份:");
    		Scanner scanner=new Scanner(System.in);
    		int year=2019;
    		int month=scanner.nextInt();
    		int day=24;//当月几号
    		int sum=day;//存储天数
    		//判断闰年多的一天
    		if(month>2) {
    			if(year%4==0&&year%100!=0||year%400==0) {
    				sum+=1;
    			}
    		}
    		switch (month-1) {
    		case 11:
    			sum+=30;
    		case 10:
    			sum+=31;
    		case 9:
    			sum+=30;
    		case 8:
    			sum+=31;
    		case 7:
    			sum+=31;
    		case 6:
    			sum+=30;			
    		case 5:
    			sum+=31;
    		case 4:
    			sum+=30;
    		case 3:
    			sum+=31;
    		case 2:
    			sum+=28;
    		case 1:
    			sum+=31;
    			break;
    		}
    		System.out.println(sum+"天");
    

    if…else语句

    //练习:判断闰年!如果对4整除100不整除,或者对400整除则为闰年!
    		int year =2019;
    		if((year%4==0 && year%100!=0)|| year%400==0 ) {
    			System.out.println(year+"是闰年");
    		}else {
    			System.out.println(year+"不是闰年");
    		}
    

    数组

    数组的规则
    数据类型[] 变量名={元素1,元素2…}
    数据类型[] 变量名=new 数据类型[元素个数];

    		int[] arr1= {2, 8};//静态创建
    		int[] arr2= new int[10];//动态创建
    		int[] arr3= {};//在内存中没有空间!用不了
    

    加粗文本 加粗文本

    下标:就是元素在数组中的编号;从0开始,最大是元素个数-1;
    数组注意事项:
    直接数出数组时,打印的是数组的地址!
    不可以直接对数组做运算,可以对数组中的元素做运算

    		//如何访问数组中的每一个元素
    		int[] arr5= {3,9,12,27,34,10,6,1};
    		for(int i=0;i<arr5.length;i++) {
    			System.out.println(arr5[i]);
    		}
    

    随机数

    		Random random=new Random();
    		int num =random.nextInt(28-20+1)+20;
    		//random.nextInt();  随机整数 有正负之分
    		//random.nextInt(n);   随机范围0到(n-1)
    		//random.nextInt(11)+18;18--28  random.nextInt(28-18+1)+18;
    		//区间值[min,max] nextInt(max-min+1)+min;//大范围减小范围+1取余+小范围
    		System.out.println(num);
    		//练习:定义数组,存储10个整数取值[30,90];获取所有的元素和
    		//以及最大值和最小值
    		System.out.println("---------------------");
    		int[] arr6=new int[10];
    		int max=0;
    		int min=90;		
    		int sum=0;
    		for(int i=0;i<arr6.length;i++) {
    			arr6[i]=random.nextInt(90-30+1)+30;
    			System.out.println(arr6[i]);
    			if(max<=arr6[i]) {
    				max=arr6[i];
    			}
    			if(min>=arr6[i]) {
    				min=arr6[i];
    				
    			}
    			sum+=arr6[i];
    		}
    		System.out.println("=====================");
    		System.out.println(max);
    		System.out.println(min);
    		
    		/*
    		 * 练习2:在练习1的基础上,获取最大数和最小数的位置下标!
    		 * 
    		 * */
    			System.out.println("==========================");	
    		 
    		for(int i=0;i<10;i++) {
    			if(max==arr6[i]) {
    				System.out.println("最大值下标"+i);
    			}
    			if(min==arr6[i]) {
    				System.out.println("最小值下标是"+i);
    				continue;
    			}
    		}
    		
    		
    		/*
    		 * 练习3:定义两个整数数组,分别存储5个整数取值范围[20,50]
    		 * 将两个数组拼接成一个元素长度为10的数组!
    		 * */
    		System.out.println("===================");
    		int[] a=new int[5];
    		int[] b=new int[5];
    		int[] c=new int[10];//(0---4)(5---9)
    		for(int i=0;i<5;i++) {
    			a[i]=random.nextInt(31)+20;
    			b[i]=random.nextInt(31)+20;
    			c[i]=a[i];
    			c[i+5]=b[i];
    			System.out.println(c[i]);
    			System.out.println(c[i+5]);
    		}
    		
    		/*
    		 * 练习4:将练习3中的大数组元素,前后对调!(例如:asdfg对调gfdsa)
    		 * */
    		System.out.println("原数组");
    			for(int i=0;i<c.length;i++) {
    				System.out.print(c[i]+" ");
    			}
    		System.out.println("\n换后");
    			for(int i=0;i<c.length/2;i++) {
    				int len=c.length;
    				int temp=c[i];
    				c[i]=c[len-i-1];
    				c[len-i-1]=temp;
    				
    				
    			}
    			for(int i=0;i<c.length;i++) {
    				System.out.print(c[i]+" ");
    			}
    

    二维数组
    二维数组 由多个一维数组组成

    		int[][] nums=new int[3][4];
    		int[][] nums1= {
    				{12,27,38,40},
    				{55,23,32,41},
    				{11,21,32,44}
    		};
    		//
    		System.out.println("\n"+nums1[1][2]);
    		//注意:对于二维数组,nums1.length 获取的是行数(一维数组的个数)
    		for(int i=0;i<nums1.length;i++) {
    			for(int j=0;j<4;j++) {
    				System.out.print(nums1[i][j]+" ");
    			}
    			System.out.println();
    		}
    
    展开全文
  • java面向对象学习心得体会 类与对象 java中所有属性和方法都在类中,一个程序可以包含一个主类,和若干类 主类public class的名称只能与文件名相同。 java的类中包括属性和方法,一般由主类进行对象实例化,new...

    java面向对象学习心得体会

    类与对象

    java中所有属性和方法都在类中,一个程序可以包含一个主类,和若干类
    主类public class的名称只能与文件名相同。
    java的类中包括属性和方法,一般由主类进行对象实例化,new一个对象的时候,系统统一开辟了一个堆内存存放属性数据,栈内存存放其堆内存的地址。给属性赋值就是与对象建立联系。

    封装性

    java中常使用private对类中属性进行封装,使用getting和setting方法用于调用
    set用于设置get用于返回给属性

    this用法

    构造方法此时没有访问类和属性的区别,往往属性前追加一个this

    public person(string name,int age)
    	{
    		this.name=name;
    		this.age=age;
    	}
    
    

    访问本类中属性时,属性前加this.
    this调用本类方法(构造与普通方法)

    普通方法调用(不强行要求添加this)

    构造方法重载this调用优化

    this()语句仅允许放在构造方法首行
    构造方法互相调用保留程序出口不形成死循环

    简单java类开发一般原则:

    类名称必须有意义,再怎么说,要让人家看的明白吧
    类之中所有属性必须使用private封装,并提供setter,getter方法
    类之中可以有多个构造方法,但是必须保留有一个无参数构造方法
    类之中不允许出现任何输出语句,所有输出必须交给被调用处
    类之中需要有一个可以取得对象完整信息的方法,一般叫做getInfo(),返回String型数据

    static关键字

    声明static属性
    重复储存数据且修改不方便,使用static用定义公共属性。
    static属性可以由类名称调用。
    static 属性虽然定义在类之中,但并不受实例化对象的控制。(在实例化之前使用)
    声明static方法
    static方法只允许调用static属性和static方法

    代码块

    代码块以{}作为分界,普通块可以划分代码结构,构造块优先于构造方法在类之中,静态块优先于构造方法,只执行一次用于给静态属性初始化,静态代码块优先于主方法。

    数组

    声明方法
    数据类型 名称 [ ] = new 数据类型 名称 [ ]
    name.length 获取数组长度
    foreach输出
    for(int temp:data)
    可变参数数组
    int … data
    类数组(类比于结构体数组)

    string类型

    string内存分析
    直接赋值,
    new 对象 会占两个空间,两个实例化对象(使用构造方法实例化string类型不会自动保存到字符串对象池)
    string常量池本质是一个数组
    public string intern()入池方法
    string对象池
    静态常量池:指的是程序(*.class)在加载的时候自动将此程序之中保存字符串普通常量类和方法信息分配。
    运行时常量池:程序加载后里面可能有些变量,提供的常量池。
    字符串内容不可修改(重新建立引用关系)不要频繁修改

    继承性

    class 子类(派生类) extends 父类(超类)
    子类中直接包含父类属性
    核心是扩充父类
    子类实例化定义要求
    new 子类 时系统自动实例化父类
    super()子类构造调用父类构造方法
    只能放在子类构造方法首行,对于调用父类无参构造方法没有影响。
    Java之中不允许多重继承,仅允许多层继承。
    继承关系不应超过三层。
    子类可以继承父类所有操作结构,所有私有操作为隐式继承,非私有为显示继承。

    覆写

    跟父类方法一模一样(覆盖)
    子类调用父类方法时,前面一定要添加super
    方法覆写的限制
    被覆写的方法不能有比父类方法更严格的访问权限。
    public > default > private
    方法重载和方法覆写的区别
    在这里插入图片描述

    this调用本类,再调用父类,super只能由子类调用父类
    super()和this()区别:

                            super():调用父类无形参的构造方法;
    
                            super(形参):调用父类中某个带形参的构造方法;
    
                            this(形参):调用本类中另一种形式的构造方法;
    

    注意:放在方法的首行;

    2.super和this的区别:

    super.父类的成员变量;

    super.父类的方法;

    super:当子类中的成员变量、方法和父类的相同时,实现调用父类的成员变量和方法;

    this:代表当前的对象;

                                   使用的地方:若函数的形参和成员变量同名时,需要用this.成员变量名
    

    annotation
    @Override明确覆写,没有覆写则报错
    @Deprecated 过期操作 编译显示过期api
    @SuppressWarnings 压制警告 不让警告信息出现
    多态性
    方法的多态性
    方法的重载:同一个方法名称可以根据传入的参数类型或个数不同实现不同功能执行。方法的覆写:子类不同有不同实习对象多态性:父子实例的相互转换,他有两种模式,对象向上,对象向下。
    父类 名称 = new 子类 名称 (对象向上)自动转换
    解决参数统一问题,接受参数和返回参数的统一性。方法覆写
    对象的向下转型
    需要子类特殊的定义处理(特殊功能)
    先向上转型后向下转型
    instanceof判断是否为某类对象
    名称 instanceof 类(判断名称属于类)向下转型前判断

    object类

    一个类没有父类为object类(默认继承object类)
    object类处理方法
    tostring()获取对象完整信息(与直接名字输出相同)
    覆写tostring获得全部方法取缔getinfo()
    equals()比较两个对象
    比较应在类内部具有,在子类中覆写equals方法

    public boolean equals(Objest obj){
    if(!(obj instanceof Person)){
     return false;
    }
    if(obj==null){
     return false;
    }
    if(this==obj){
    return ture;
    }
    return this.name.equals(per.name)&&this.age==per.age;
    }
    

    抽象类
    普通类加抽象方法为抽象类(不是完整的)
    public abstract string getinfo()
    抽象类必须有非抽象类的子类,必须覆写抽象方法
    抽象类使用建议
    抽象类无法直接实例化
    抽象类主要进行过渡操作使用
    抽象类不允许有final关键字
    抽象类的应用
    行为类(给定一个模板)

    包装类

    装箱:将基本数据类型保存到包装类
    拆箱:从包装类获取基本数据类型
    对象型包装类 boolean character
    数值型包装类。(number)integer byte long short float double 等
    自动拆箱与装箱
    https://blog.csdn.net/zhanghaipeng1989/article/details/45512433?utm_source=app
    接口与抽象类
    接口基本定义
    除了抽象方法和全局常量(普通方法静态方法)
    interface关键字定义接口
    接口名称前常加入I
    对于接口要求
    接口需要被子类实现,可以是多个父接口。
    需要覆写接口中所有抽象方法。
    接口对象可以利用子类对象的向上转型进行实例化。
    implement(实现)
    可实现多继承。
    接口默认权限public
    子类先继承父类,后实现接口
    接口可以继承多个接口。
    接口开发作用
    进行标准设置。
    表示一种操作能力。
    暴露远程方法视图,一般用于RPC分布式开发中。
    接口追加普通方法必须添加default
    用抽象类继承接口
    使用接口定义标准
    工厂设计模式(factory)
    代理模式,代理调用本类

    泛型

    利用object定义,多内容接收
    字符串自动包装自动拆包,[安全隐患]
    object类涵盖范围太广
    泛型定义:
    类中属性方法的参数和返回值类型由实例化时决定(用户决定)
    类声明
    默认的泛型类型为object,编译会出现警告
    public class point
    point point =new point ();
    泛型只允许引用类型,包装类
    泛型可以简化为new point<>();
    泛型的通配符
    方法引用传递
    message<?>类型
    不设置泛型,会对数据修改
    ?extends number 只允许设置number的子类(上限)
    ?super string 只允许string和其父类(下限)
    泛型接口
    泛型接口定义
    子类中接着用泛型
    子类中定义泛型类型
    泛型方法
    泛型标记写入泛型方法
    利用泛型改造工厂

    包的定义与使用

    包=目录
    package cn.cnki.n
    点作为分割号目录/
    import 导入其他包
    Javac -d .*. Java 自己匹配其他包编译。
    包导入需要public 程序包
    包为小写路径
    用*包根据使用加载
    如果两个包都有相同名称的类(引用不明确)
    静态导入
    import static 路径.类名
    导入后无需类名调用方法
    jar文件打包
    先编译后打包(根目录jar打包)
    jar -cvf 包名.jar 根目录
    引入需要 classpath jar 路径用分号分隔

    枚举类型

    异常处理

    try{ 可能产生异常的片段
    }
    catch(异常类型1){ 异常处理办法
    }
    catch(异常类型2){ 异常处理办法
    }
    finally{ 不管是不是有异常都执行
    }

    程序运行中产生异常,try语句捕获实例化对象,异常类型是核心,error程序未执行的错误,exception程序执行后出现的错误,可以被认为处理
    所有异常都可以用exception e处理,不确定用exception处理可用,最好对异常分开处理,最大范围放在后面

    throws关键字

    public static int div (int a,int b) throws exception
    

    有throws必须用try catch 异常处理
    自定义exception 用类继承exception或者runtimeexception

    内部类

    为什么要有内部类
    轻松使用外部类私有属性
    外部类先实例化内部类再实例化

    展开全文
  • Java循环中的for循环简单示例: for 循环的语法结构: for(表达式1;表达式2;表达式3){ 循环语句 } for循环的执行流程是:  首先执行表达式1,一般是进行变量初始化操作,然后执行表达式2,即对循环...

    Java循环中的for循环简单示例:

    for 循环的语法结构:

    for(表达式1;表达式2;表达式3){
        循环语句
    }
    

    for循环的执行流程是:

          首先执行表达式1,一般是进行变量初始化操作,然后执行表达式2,即对循环条件进行判断,如果结果为真,则执行循环体;循环体执行完毕后,执行表达式3,改变循环变量的值,再次执行表达式2;结果为真,继续循环;如果结果为假,则终止循环,执行后面的语句。

          无论执行多少次,表达式1仅执行一次。而且for循环中的3个表达式都可以省略,写在循环体外、内。

    /**
    *计算1到100的和
    */
    public class Summation {
    
        public static void main(String[] args) {
            int sum = 0; //声明变量sum存放计算的和,赋初值为0
            for(int i=1;i<=100;i++)
                sum +=i;//等价于语句sum=sum+score
            System.out.println("sum="+sum);
        }
    
    }

    运行结果:sum=5050

    //		菱形
    		for(int i=1;i<=3;i++){
    			for(int j=1;j<=3-i;j++){
    				System.out.print(" ");
    			}
    			for(int j=1;j<=2*i-1;j++){
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    		for(int i=1;i<3;i++){
    			for(int j=1;j<=i;j++){
    				System.out.print(" ");
    			}
    			for(int j=1;j<=5-2*i;j++){
    				System.out.print("*");
    			}
    			System.out.println();
    		}


    展开全文
  • } while(条件判断语句); (2)完整格式: 初始化语句; do { 循环体语句; 条件控制语句; } while(条件判断语句); 2、执行流程: (1)执行初始化语句; (2)执行循环体语句; (3)执行条件控制语句; (4...
  • 首先,我初涉Java觉得这是一门高大上的学问,带着这样的感觉,我开始了我的Java之旅。在学习过程中,我很少有放弃的念头,知道这是为什么么?兴趣,所以说,兴趣是学习这门课的垫脚石。其次,上
  • 循环语句学习总结

    2018-12-09 14:36:43
    1.如何判断什么时候用什么语句: 若循环次数一定,计数控制的循环用for循环。 若循环次数未知,条件控制的循环用while循环。 若循环次数至少执行一次用do-while循环。 2.嵌套循环的概念: 在一个循环语句中又...
  • while循环语句和选择结构if语句有些相似,都是根据条件判断来决定是否执行大括号内的执行语句。区别在于,while语句会反复地进行条件判断,只要条件成立,{}内的执行语句就会执行,直到条件不成立,while循环结束。...
  • Java包和import语句

    2018-10-13 10:04:36
    包 包是Java语言中有效的管理类的一...package语句需要放在Java源文件的第一条语句,指明该源文件定义的类所在的包,即为该源文件中声明的类指定包名。 一般格式: package 包名;//包名是一个合法的标识符或者若干个...
  • 一、分支语句 1.if语句 if语句是单重选择,最多只有两个分支。if语句的基本格式是: if(逻辑表达式) 语句1; [else if 语句2; else 语句3; ] 使用嵌套的if语句可以实现多重选择,可以有多个分支。 if...
  • Java 控制语句

    2019-12-16 15:18:28
    Java 控制语句 ???? 本文已归档到:「javacore」 ???? 本文中的示例代码已归档到:「javacore」 Java 控制语句大致可分为三大类: - 选择语句 - if, else-if, else - switch - 循环语句 - while - do...while - ...
  • Java中do…while循环语句用法叩丁狼详解  程序的优势是可以解放人的双手去做其他更有意义的事情,重复的劳动都交给编写好的程序去完成。在Java中有一种特殊的语句叫做循环语句,它可以实现将一段代码重复执行,例如...
  • Java语言的学习进程

    2019-08-31 16:42:42
    Java语言的学习进程 之前我们学习了变量的概念和一些常用的数据类型...对于很多复杂的需求,基本的条件判断语句也解决不了,因此,我们还要学习复杂的选择结构,主要包括多重if选择结构,嵌套if选择结构。要理解每种...
  • Java多线程学习心得

    2015-08-17 17:45:36
    java中的多线程 在java中要想实现多线程,有两种手段,一种是继承Thread类,另外一种是实现Runable接口。 对于直接继承Thread的类来说,代码大致框架是: 1 2 3 4 5 6 7 8 9 10 11 12 ...
  • 本文目录前言Java基础疑难点Java面向对象疑难点word版下载 前言   大家好,我是工程小猿!之前在学习Java语言的过程中总是遇到一些问题,比如在看基础知识时,发现它和C语言基本语法差别不大,除了没有C语言中...
  • 1、条件语句(1)if条件语句if(条件){语句块1}else{语句块2}条件可以是:1、一个boolean值;2、可以是一个boolean类型的变量;3、可以是一个返回值为boolean类型的表达式;(2)嵌套if条件语句if(条件1){//语句块1if...
  • 一、选择结构语句 ...Java语言提供了两种选择结构语句:if语句和switch语句 1、if语句 if语句有三种语法格式。 (1)、if语句第一种语法格式(适合一种判断) if(条件表达式){ 语句体; } 执行流程:判断
  • 主要整理一下容易出错的switch和控制跳转。 switch语句 控制跳转语句 switch语句1、格式: switch(表达式) { case 值1: 语句体1; break; case 值2: 语句体2; break; ... d
1 2 3 4 5 ... 20
收藏数 11,896
精华内容 4,758