精华内容
下载资源
问答
  • 变量是内存一个存储区域,该区域自己的名称(变量名)和类型(数据类型),Java中每个变量必须先声明,后使用, 该区域的数据可以在同一类型范围内不断变化。 声明格式 数据类型 变量名 = 初始化值; 变量的...

    变量

    变量的定义

    变量是内存中的一个存储区域,该区域有自己的名称(变量名)和类型(数据类型),Java中每个变量必须先声明,后使用, 该区域的数据可以在同一类型范围内不断变化。

    声明格式

    数据类型 变量名 = 初始化值;

    变量的分类

    按数据类型

    对于不同的数据类型,变量在内存中分配了不同大小的内存空间,数据类型分为基本数据类型和引用数据类型:

    • 引用数据类型:
      • 类(class)
      • 接口(interface)
      • 数组
    • 基本数据类型:
      • 布尔型(boolean)
      • 字符型(char)
      • 数值型:
        • byte
        • short
        • int
        • long
      • 浮点类型:
        • float
        • double

    按声明的位置

    在方法体外,类体内声明的变量称为成员变量;在方法体内部声明的变量称为局部变量:

    • 成员变量:
      • 实例变量(不以static修饰)
      • 类变量(以static修饰)
    • 局部变量:
      • 形参(方法签名中定义的变量)
      • 方法局部变量(在方法内定义的)
      • 代码块局部变量(在代码块内定义)

    成员变量和局部变量在初始化值方面的异同:

    • 相同点:都有声明周期
    • 不同点:局部变量除形参外,需要显示初始化

    常量

    常量是一种特殊的变量,它的值被设定后,在程序运行过程中不允许改变。

    常量的定义

    语法:
    final 常量名 = 值;
    常量必须要在声明的时候就对其进行初始化,否则会出现编译错误。常量一旦初始化后就无法再改动。

    字符型常量

    字符型常量的三种表现形式:

    1. 字符常量是用单引号括起来的单个字符,涵盖世界上所有书面语的字符。
      例如:
    char c1 = 'a';
    char c2 = '中'; 
    char c3 = '9';
    
    1. Java中还允许使用转义字符 ‘\’ 来将其后的字符转变为特殊字符型常量。
      例如:
    // '\n'表示换行符
    char c = '\n'; 
    
    1. 直接使用 unicode 值来表示字符型常量:‘\uXXXX’。其中,‘XXXX’ 代表一个十六进制整数。
      例如:
    // '\u000a' 表示 '\n'
    char c = '\u000a';
    
    展开全文
  • Java变量和常量定义及初始化

    万次阅读 2019-01-24 11:48:57
     变量是内存一个存储区域,该区域自己的名称(变量名)和类型(数据类型),Java中每个变量必须先声明,后使用, 该区域的数据可以在同一类型范围内不断变化。  2.变量的分类  1)按数据类型  对于不同...

    一、变量

        1.变量的定义

              变量是内存中的一个存储区域,该区域有自己的名称(变量名)和类型(数据类型),Java中每个变量必须先声明,后使用, 该区域的数据可以在同一类型范围内不断变化。

        2.变量的分类

            1)按数据类型

                   对于不同的数据类型,在内存中分配了不同大小的内存空间

                   数据类型分为基本数据类型和引用数据类型,引用数据类型有类(class)、接口(interface)、数组,基本数据类型有布尔型(boolean)、字符型(char)、数值性【整数类型(byte、short、int、long)、浮点类型(float、double)】

          2)按声明的位置

                   在方法体外,类体内声明的变量称为成员变量;在方法体内部声明的变量称为局部变量

        3.声明格式

             定义变量的格式:数据类型 变量名 = 初始化值

             变量在内存中的区域:

    二、常量

          常量是一种特殊的变量,它的值被设定后,在程序运行过程中不允许改变,一般用大写字符

                语法:final 常量名 = 值;如:final String LOVE = ‘java‘;

          注意:必须要在常量声明的时候就对其进行初始化,否则会出现编译错误。常量一旦初始化后就无法再改动

         字符型常量的三种表现形式:

                1.字符常量是用单引号(‘ ’)括起来的单个字符,涵盖世界上所有书面语的字符。例如:char c1 = ‘a‘; char c2 = ‘中‘; char c3 = ‘9‘;

                2.Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如:char c3 = ‘\n’; // ‘\n‘表示换行符

                3.直接使用 Unicode 值来表示字符型常量:‘\uXXXX’。其中,XXXX代表一个十六进制整数。如:\u000a 表示 \n

    展开全文
  • Java 常量都可以定义在哪里?

    千次阅读 2019-03-04 16:12:44
    1、常量提取出来有利于代码阅读,而且下次再做这种判断不用手写或复制,直接通过常量类就能得到,能够避免的地方是username,的地方是name来判断同一个逻辑含义相同变量问题。 不过我觉得提取出来并不会有利于...

    哈哈,很搞笑的问题吧!可是小编在实际开发中还真的遇到了一个相关的麻烦,敦促我把这个知识点梳理一下。大神可以飘过,小白还真是要了解一下的好。

    常量使用目的

    1、常量提取出来有利于代码阅读,而且下次再做这种判断不用手写或复制,直接通过常量类就能得到,能够避免有的地方是username,有的地方是name来判断同一个逻辑含义相同变量问题。
    不过我觉得提取出来并不会有利于代码性能提升,因为常量分配在内存的常量池中,所以内存不会出现多个相同常量字符串。总的来说提取常量主要是为了避免魔法数字和提高代码可读性。
    2、常量定义在 final 的 clas 中,防止被其它类继承和实例化。定义在 interface 中性质也是一样,static final属性。但是 interface 看起来就是会被实现的。

    项目场景

    小编在做一个三方的业务对接时,业务方要求变更配置好的static final常量。当小编改变定义的常量值之后,遇到这样一个问题,就是将文件上传到服务器上后,发现引用这个常量的代码并没有变成新的值。

    这是典型的java常量替换的应用,也是因为不够理解java常量替换的机制导致的问题。

    举个小例子:

    	@Test
    	public class Test {
    		String a = "a";
    		String b = "b";
    		String str1 = a + b;
    		String str2 = "a" + "b";
    	}
    

    以上代码 str2 会在编译时就确定下值来,因为是两个字符串常量的连接值,字符串常量本身就是一个宏变量,而 str2 则不行,因为编译时无法确定 a 与 b 的值,如果把 a 与 b 变量定义为 final 变量,则 str1 就可以在编译时确定值。

    修改办法:
    其实,只需要将引用该常量新值的 java 文件重新编译成为 class 文件,并上传到服务器上即可。

    原理:
    当final修饰一个变量时,必须为该变量显示指定初始值,那么这个变量在编译时就可以确定下来,那么这个final变量实质上就是一个“宏变量”,编译器会把程序中所有用到该变量的地方替换成该变量的值。

    而宏替换的过程是在java编译中执行的,也就是说 java 文件在编译时就直接将 final 变量替换为对应的值。当我们将final变量所在的 java 源文件编译成 class 文件后,上传到服务器上,但是引用这个 final 变量的 class 文件,依然是在引用旧的 final 变量时编译的,所以才需要将引用新的 final 变量的 class 文件上传到服务器上才可以。

    常量定义场景

    1、interface中定义常量:接口(Interface)的中变量默认为static final的

    public interface ConstantInterface {  
        String SUNDAY = "SUNDAY";  
        String MONDAY = "MONDAY";  
        String TUESDAY = "TUESDAY";  
        String WEDNESDAY = "WEDNESDAY";  
        String THURSDAY = "THURSDAY";  
        String FRIDAY = "FRIDAY";  
        String SATURDAY = "SATURDAY";  
    }
    

    2、普通类中定义常量:在普通类中使用 static final 修饰变量

    public class ConstantClassField {  
    	public static final String SUNDAY = "SUNDAY";  
    	public static final String MONDAY = "MONDAY";  
    	public static final String TUESDAY = "TUESDAY";  
    	public static final String WEDNESDAY = "WEDNESDAY";  
    	public static final String THURSDAY = "THURSDAY";  
    	public static final String FRIDAY = "FRIDAY";  
    	public static final String SATURDAY = "SATURDAY";  
    }
    

    3、也可以使用get方法:注意,这个类里可没有set方法!!

    public class ConstantClassFunction {  
    	private static final String SUNDAY = "SUNDAY";  
    	private static final String MONDAY = "MONDAY";  
    	private static final String TUESDAY = "TUESDAY";  
    	private static final String WEDNESDAY = "WEDNESDAY";  
    	private static final String THURSDAY = "THURSDAY";  
    	private static final String FRIDAY = "FRIDAY";  
    	private static final String SATURDAY = "SATURDAY";  
    	public static String getSunday() {  
    		return SUNDAY;  
    	}  
    	public static String getMonday() {  
    		return MONDAY;  
    	}  
    	public static String getTuesday() {  
    		return TUESDAY;  
    	}  
    	public static String getWednesday() {  
    		return WEDNESDAY;  
    	}  
    	public static String getThursday() {  
    		return THURSDAY;  
    	}  
    	public static String getFirday() {  
    		return FRIDAY;  
    	}  
    	public static String getSaturday() {  
    		return SATURDAY;  
    	}  
    }
    

    4、final class 定义常量:final类可以通过“类名.”的方式直接取值

    public final class ConstantClassField {  
    	public static final String SUNDAY = "SUNDAY";  
    	public static final String MONDAY = "MONDAY";  
    	public static final String TUESDAY = "TUESDAY";  
    	public static final String WEDNESDAY = "WEDNESDAY";  
    	public static final String THURSDAY = "THURSDAY";  
    	public static final String FRIDAY = "FRIDAY";  
    	public static final String SATURDAY = "SATURDAY";  
    }
    

    5、写在properties文件中:下面是读取 properties 文件的方法

    public static String getProperties(String str) {
    	try {
    		Properties prop = new Properties();
    		InputStream fis = PropertiesUtil.class.getClassLoader().getResourceAsStream("项目下properties的文件名");
    
    		return prop.getProperty(str).trim();
    	} catch (Exception e) {
    		e.printStackTrace();
    	} finally {
    		// 当通过Properties读取文件后,流应当自行关闭
    		prop.load(fis);
    		fis.close();
    	}
    	return null;
    }
    
    建议
    1. 如果是一般业务场景,小编推荐使用第4种 – final class定义,和其它方法比:简洁,表面意思更清楚,不用实现接口,唯一性,通用性也更好。
    2. 如果有的变量在部署的时候可能会根据环境的不同而改变,则建议把常量写到properties文件中。
      就比如我上面的业务场景,如果之前是把常量写在properties文件中,则不会存在上传编译文件的麻烦,直接修改properties文件中的属性即可。因为properties文件中的值是重新加载的,并不适用常量替换的机制。

    更多精彩,请关注我的"今日头条号":Java云笔记
    随时随地,让你拥有最新,最便捷的掌上云服务

    展开全文
  • 1、Java语言拼写上严格区分大写; 一个Java源文件里可以定义多个Java类,但其中最多只能一个被定义成public; 若源文件包括了public,源文件必须和该public同名...我的总结:一个Java源文件只定义一个类

    1、Java语言拼写上严格区分大小写
    一个Java源文件里可以定义多个Java类,但其中最多只能有一个类被定义成public类;
    若源文件中包括了public类,源文件必须和该public类同名;
    一个源文件中包含N个Java类时,编译后会生成N份字节码文件,即每个类都会生成一份单独的class文件,且字节码文件名和
    其对应的类名相同;


    我的总结:一个Java源文件只定义一个类,不同的类使用不同的源文件定义;
    将每个源文件中单独定义的类都定义成public的;
    保持Java源文件的主文件名与源文<FONT color=#ff0000>件中的类名一致;




    2、Java语法格式
    任何一种语言都有自己的语法规则,Java也一样,既然是规则,那么知道其如何使用就可以了。
    代码都定义在类中,类由class来定义,区分 public class  和  class;
    代码严格区分大小写,如main 和 Main  是不一样的;
    Java中的标识符与关键字;
    注释;


    main方法的作用:
    程序的入口
    保证程序的独立运行
    被JVM调用


    3、代码注释:单行//,多行/* */,文档注释/** */
    1.单行注释      //:
    //后到本行结束的所有字符会被编译器忽略;
    2.多行注释     /* */:
    /*  */之间的所有字符会被编译器忽略
    3.文档注释     /** */:
     在/**  */之间的所有字符会被编译器忽略,java特有的(用于生成文档);
    我的总结:多行和文档注释都不能嵌套使用。


    4、Java中的标识符
    可简单理解为在Java程序中为了增强阅读性自定义的名称。比如:类名,方法名,变量名等。
    命名规则:
    (1) 由字母、数字、下划线、$组成,不能以数字开头
    注意:此处的字母还可以是中文,日文等;
    (2) 大小写敏感
    (3) 不得使用java中的关键字和保留字
    (4) 别用Java API里面的类名作为自己的类名。


    5、java中的常量和变量
    变量的概念:
    占据着内存中的某一个存储区域;
    该区域有自己的名称(变量名)和类型(数据类型);
    该区域的数据可以在同一类型范围内不断变化;


    为什么要定义变量:
    用来不断的存放同一类型的常量,并可以重复使用;
    使用变量注意:
    变量的作用范围, 初始化值
    定义变量的格式:
    数据类型    变量名  =  初始化值;
    注:格式是固定的,记住格式,以不变应万变。
    作用范围:定义开始到定义它的代码块结束;
    同一范围内,不允许多个个局部变量命名冲突


    6、Java成员变量和局部变量
    局部变量:不是声明在类体括号里面的变量;
    局部变量使用前必须初始化值;
    局部变量没有默认初始化值;
    局部变量的作用域是从定义开始到定义它的代码块结束;


    成员变量:在方法体外,类体内声明的变量,又称字段(Field)或全局变量;
    (其实Java中没有全局变量,由于Java是面向对象语言 ,所有变量都是类成员)
    成员变量的作用域是整个类中;
    我的总结:注意成员变量和局部变量的区别




    package reviewDemo;
    
    
    public class Demo2 {
     public static void main(String[] args) {
         int i;
           System.out.println(i);
       }
    }




    备注:局部变量调用前没有初始化,所以编译的时候就会报错!




    package reviewDemo;
    
    
    public class Demo2 {
      static int i;
        public static void main(String[] args) {
         System.out.println(i);
       }
    }




    备注:此时i为全局变量,未初始化会被赋予默认的初始化值!程序正确!


    总结:
    局部变量是定义在方法中的变量,,,出了该方法就不能访问该变量了....
    成员变量是在类中定义,,,,并且在类的成员方法中都能访问的变量..




    7、基本数据类型
    在数据类型中,最常用也是最基础的数据类型,被称作基本数据类型。可以使用这些类型的值来代表一些简单的状态。
    Java 语言的基本数据类型总共有以下8 种,下面是按照用途划分出的4 个类别: 



    定点类型:
    整数型是一类代表整数值的类型。当需要代表一个整数的值时,可以根据需要从4 种类型中挑选合适的,如果没有特殊要求的话,一般选择int 类型。4 种整数型区别主要在每个数据在内存中占用的空间大小和代表的数值的范围。



    浮点类型:
    小数型是一类代表小数值的类型。当需要代表一个小数的值时,可以根据需要从以下2 种类型中挑选合适的。如果没有特殊要求,一般选择double类型。
    由于小数的存储方式和整数不同,所以小数都有一定的精度,所以在计算机中运算时不够精确。根据精度和存储区间的不同,设计了两种小数类型。



    字符型:
    字符型代表特定的某个字符,按照前面介绍的知识,计算机中都是以字符集的形式来保存字符的,所以字符型的值实际只是字符集中的编号,而不是实际代表的字符,由计算机完成从编号转换成对应字符的工作。Java 语言中为了更加方便国际化,使用Unicode 字符集作为默认的字符集,该字符集包含各种语言中常见的字符。在程序代码中,字符使用一对单引号加上需要表达的字符来标识,例
    如’A’、’a’等,当然也可以直接使用字符编码,也就是一个非负整数进行表示。





    布尔型:
    布尔型代表逻辑中的成立和不成立。Java 语言中使用关键字true 代表成立,false 代表不成立。布尔型是存储逻辑值的类型,其实很多程序中都有逻辑值的概念,Java 把逻辑的值用布尔型来进行表达。



    8、基本数据类型转换之向上转型和向下转换


    向上转换:


    整型,字符型,浮点型的数据在混合运算中相互转换,转换时遵循以下原则:
    容量小的类型可自动转换为容量大的数据类型;
    byte,short,char → int → long → float → double
    byte,short,char之间不会相互转换,他们在计算时首先会转换为int类型。
    boolean 类型是不可以转换为其他基本数据类型。

    int i = 123;
    long l = i; //自动转换,不需强转
    float f = 3.14F;
    double d = f;


    向下转换:


    整型,字符型,浮点型的数据在混合运算中相互转换,转换时遵循以下原则:
    容量小的类型可自动转换为容量大的数据类型;
    byte,short,char → int → long → float → double
    byte,short,char之间不会相互转换,他们在计算时首先会转换为int类型。
    boolean 类型是不可以转换为其他基本数据类型。
    Eg:
    long l = 123L;
    int i = (int) l;//必须强转
    double d = 3.14;
    float f = (float) d;


    我的总结:类型转化
    小转大,自动!自动类型转换(也叫隐式类型转换)  
    大转小,强转!强制类型转换(也叫显式类型转换) 


    9、Java的运算符
    运算符是一种特殊符号,用以表示数据的运算、赋值和比较等共分以下几种: 


    算术运算符(+ 、- 、* 、/ 、%)
    赋值运算符(= 、+=、-=、*=、/=,、%=)
    关系运算符(&amp;gt;、&amp;gt;=、&amp;lt;、&amp;lt;=、!=)
    条件运算符(&amp;amp;&amp;amp;、||、!&amp;amp;、|、^)
    位运算符(&amp;amp;、|、^、~、&amp;gt;&amp;gt;、&amp;lt;&amp;lt;、&amp;lt;&amp;lt;&amp;lt;、&amp;gt;&amp;gt;&amp;gt;)


    总结:


    逻辑运算符用于连接布尔型表达式,在Java中不可以写成3&amp;lt;x&amp;lt;6,应该写成x&amp;gt;3 &amp;amp; x&amp;lt;6 。
    “&amp;amp;”和“&amp;amp;&amp;amp;”的区别:单与时,左边无论真假,右边都进行运算;双与时,如果左边为真,右边参与运算,如果左边为假,那么右边不参与运算。
    “|”和“||”的区别同理,双或时,左边为真,右边不参与运算。
    “ ^ ”与“|”不同之处是:当左右都为true时,"^"结果为false。


    10、表达式和三目运算符
    是由数字、运算符、数字分组符号(括号)等以能求得数值的有意义排列的序列;
    a + b
    3.14 + a
    (x + y) * z + 100
    boolean b= i &amp;lt; 10 &amp;amp;&amp;amp; (i%10 != 0)
    表达式的类型和值:
    对表达式中操作数进行运算得到的结果是表达式的值。
    表达式值的数据类型即为表达式的类型。
    表达式的运算顺序
    应按照运算符的优先级从高到低的顺序进行;
    优先级相同的运算符按照事先约定的结合方向进行;




    “三目运算符”,语法格式:
    x ? y : z;
    其中x为boolean类型表达式,先计算x的值,若为true,则整个三目运算符的结果是表达式y的值,否则就是z的值。


    package reviewDemo;
    
    
    public class Demo2 {
    	public static void main(String[] args) {
    		String  s = "lz";
    		s = (s == "lz" ? "正确" : "错误");
    		System.out.println(s);
    	}
    }


    输出:正确


    11、程序流程控制
    顺序结构
    分支结构(条件结构)
    循环结构
    控制循环结构


    顺序结构:
    如果代码里没有流程控制,程序是至上而下一行一行执行的,一条语句执行完之后继续执行下一条语句,直到程序的最后。


    if语句:
    基本语法:if(表达式){方法体}else if(表达式){方法体}else(方法体)
    几种形式:
    三种格式:
    if(条件表达式){执行语句;}
    if(条件表达式){执行语句;}else{执行语句;}
    if(条件表达式){执行语句;}else if (条件表达式){执行语句;}……else{执行语句;}


    public class If3 
    {
    	public static void main(String args[])
    	{
    		int i = 3;
    		if (i &gt; 5)
    		{
    			System.out.println("变量i大于5");
    		}
    		else if (i &gt; 4)
    		{
    			System.out.println("变量i小于4");
    		}
    		else
    		{
    			System.out.println("其他");
    		}
    	}
    }




    switch控制语句
    格式:
    switch(表达式)
    {
    case 表达式可能的结果值1:
    执行语句;
    break;
    case 表达式可能的结果值2:
    执行语句;
    break;
    ...
    default:
    执行语句;
    break;//最后这个一般不写
    }
    备注:
    case之间与default没有顺序。先执行第一个case,都没有匹配的case值执行default。
    结束switch语句的两种情况:遇到break,switch语句执行结束。
    如果匹配的case或者default没有对应的break,那么程序会从第一次匹配的case语句开始继续向下执行,运行可以执行的语句,直到遇到break或者switch结束为止。
    class switch2 
    {
    	public static void main(String[] args) 
    	{
    		int a = 7,b = 5;
    		switch(a-b)
    		{
    			case 3://表达式可能的值;
    			{
    				System.out.println("33!");
    			}
    			break;
    
    
    			case 4:
    			{
    				System.out.println("44!");
    				}
    				break;
    				default://都没有执行则 执行该语句!
    					System.out.println("其它的");
    
    
    		}
    	}
    }


    注意:switch语句只能使用byte、char、short、int四种基本类型以及它们的包装类和枚举


    12、三大循环结构:


    用于处理需要重复执行的操作;
    根据判断条件的成立与否,决定程序段落的执行次数,而这个程序段落我们称为循环体;
    while:事先不需要知道循环执行多少次;
    do  while:同上,只是至少要执行一次(先做,后判断);
    for:需要知道循环次数;


    循环结构(while &amp;amp; do while)
    while语句
    格式:
    while(条件表达式值为true)
    {
    执行语句;
    }


    do while语句
    格式:
    do
    {
    执行语句;
    }
    while(条件表达式值为true);


    我的总结:do while特点是无论条件是否满足,循环体至少被执行一次。
    循环里的条件表达式不能直接写false或直接写结果是false的表达式,不过可以使用变量来传递false值;


    循环结构(for)
    格式:
    for(初始化表达式(1);循环条件表达式(2);循环后的操作表达式(3))
    {
    执行语句;(4)
    }
    执行顺序:(1) → (2) → (4) → (3) → (2) → (4) → (3)


    备注:
    1, for里面的3个表达式运行的顺序,初始化表达式只读一次,判断循环条件,为真就执行循环体,然后再执行循环后的操作表达式,接着继续判断循环条件,重复找个过程,直到条件不满足为止。
    2, while与for可以互换,区别在于for为了循环而定义的变量在for循环结束就在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
    3, 最简单无限循环格式:while(true) , for(;;),无限循环存在的原因是并不知道循环多少次,而是根据某些条件,来控制循环。


    Eg:
    用三种循环控制求出100以内前5个3的倍数的数字;


    class while
    {
    	public static void main(String[] args) 
    	{
    		int i = 1,k = 0;
    		while(i&lt;=100)
    		{
    			if(i%3==0)
    			{
    			if(k&lt;5)
    			System.out.println(i);
    			k++;
    			}
    			i++;
    		}
    	}
    }




    class dowhile
    {
    	public static void main(String[] args) 
    	{
    		int i = 1,k = 0;
    		do{
    			if(i%3==0)
    			{
    			if(k&lt;5)
    			System.out.println(i);
    			k++;
    			}
    			i++;
    		}
    		while(i&lt;=100);
    	}
    }




    class for
    {
    	public static void main(String[] args) 
    	{
    		int i = 1,k = 0;
    		for(;i&lt;100;i++)
    		{
    			if(i%3==0&amp;&amp;k&lt;5)
    			{
    			System.out.println(i);
    			k++;
    			}
    		}
    	}
    }




    13、嵌套循环与流程控制
    嵌套循环:循环里套循环
    假设外循环的循环次数是m次,内循环的循环次数是n次,那么内层循环的循环次数需要 m * n次。


    Eg:利用for循环语句的嵌套打印出乘法口诀表


    class break1 
    {
    	public static void main(String[] args) 
    	{
    		for(int i=1;i&lt;=10;i++)//定义i与j的值必须在for循环里面,否则每次跳出循环重新执行就无法取值
    		{
    			for(int j=1;j&lt;=10;j++)
    			{
    				if(j&lt;=i)
    				System.out.print(j+"*"+i+"="+i*j+" ");//小注意:print()括号里面
    必须传递参数,println()无限制!
    			}
    				System.out.println();
    		}
    	}
    }




    流程控制


    break语句、 continue语句;


    break:终止该层循环;
    continue:跳过该层循环
    注:
    ①:若这两个语句离开应用范围,存在是没有意义的。
    ②:这个两个语句后面都不能有语句,因为执行不到。
    ③:continue语句是跳过本次循环,继续下次循环。
    ④:标签的出现,可以让这两个语句作用于指定的循环。


    Eg:
    package reviewDemo;
    
    
    public class Demo2 {
    	public static void main(String[] args) {
    		int i = 1;
    		for (; i &lt; 10; i++) {
    			System.out.println(i);
    			if(i == 8){
    				break;//流程控制,不会完全执行!
    			}
    		}
    	}
    }
    

    最后附上JDK使用文档API 下载

    展开全文
  • Java中的数据类型 A:为什么数据类型 Java语言是强类型语言,对于每一种数据都定义了明确的具体数据类型,在内存分配了不同大小的...byte 占一个字节 -128到127 short 占两个字 -2^15~2^15-1 int 占四个字...
  • Java变量和常量声明

    2018-05-25 08:19:00
    变量是内存一个存储区域,该区域自己的名称(变量名)和类型(数据类型),Java中每个变量必须先声明,后使用 该区域的数据可以在同一类型范围内不断变化 2.变量的分类 1)按数据类型 对于每一种数据都...
  • JAVA_API1.6文档(中文)

    万次下载 热门讨论 2010-04-12 13:31:34
    java.sql 提供使用 JavaTM 编程语言访问并处理存储在数据源(通常是一个关系数据库)的数据的 API。 java.text 提供以与自然语言无关的方式来处理文本、日期、数字和消息的和接口。 java.text.spi java.text ...
  • Java枚举的一些

    2020-02-23 21:35:32
    枚举类型用于声明一组命名的常数,当一个变量几种可能的取值时,可以将它定义为枚举类型。 2.枚举的作用 (1)简化代码,让代码更加优雅。在没有枚举类型的时候,只能使用许多静态常量来标记所需要的常量。这常常...
  • 变量是内存一个存储区域,该区域自己的名称(变量名)和类型(数据类型),Java中每个变量必须先声明,后使用 该区域的数据可以在同一类型范围内不断变化 2.变量的分类 1)按数据类型 对于每一种数据都...
  • 本节课的框架 一、变量 1.变量的基本简介 在java当中每一个变量都有一个类型(type),在声明变量时,变量的类型位于变量名之前。...全局变量使用来描述我们这个对象当中什么的(在类中定义和方法同级),作用
  • 我们可以说A类中有一个成员变量叫做s,A类有一个字段s 。 字段一般用来承载数据,所以为了安全性,一般定义为私有的。 字段和常量描述了类的数据(域),当这些数据的某些部分不允许外界访问时,根据 “对象封装” ...
  • Java 标识符是为方法、变量或者其他用户定义定义的名称。 标识符用来对变量、常量和方法等进行命名。 标识符命名规则: 标识符由数字(0~9)、美元符号($)、下划线(_)以及Unicode字符集组合构成; ...
  • 1. 标识符 Java 标识符是为方法、...Java中的关键字是对编译器特殊意义的词,比如class是用来定义类的关键字,编译器遇到class就知道这是定义一个类。 abstract boolean break byte case catch char
  • }我们可以说A类中有一个成员变量叫做s,A类有一个字段s 。字段一般用来承载数据,所以为了安全性,一般定义为私有的。字段和常量描述了类的数据(域),当这些数据的某些部分不允许外界访问时,根据 “对象封装” 的...
  • 在输出x的值还是456啊 这不是变了吗 其实Java内部有个常量池 栈内存的x先指向常量池内的123 然后又把x指向了456,123在常量池还是存在的 只不过变成了垃圾 会由GC进行不定时回收,开始定义了123那么12...
  • 说明:java程序的一些基本概念,错误大家可以指出来。 、关键字与标识符 关键字:指计算机事先定义好的,特别意义的标识符,也称为保留字,如if void try等等。 标识符:指程序自定义内容、名称、变量...
  • 标识符 什么是标识符:自己定义的东西叫标识符 类名 方法名 变量名 接口名。。。 标识符命名26个英文字母 0~9数字 _或者$ 不能用关键字和保留字 ...一个内存的储存区域 该区域自己的名称和数据...
  • 变量是内存一个存储区域,该区域自己的名称(变量名)和类型(数据类型),Java中每个变量必须先声明,后使用, 该区域的数据可以在同一类型范围内不断变化。 2.变量的分类 1)按数据类型 对于不同的...
  • 每个都要有一个主函数。含有main方法的称为Java主类。 变量的声明 全局变量 这个是声明在主函数外面的 成员变量 这个是申明在主函数里面的。 里面的变量定义可以边定义边操作:long s1 = s2+s3+s4; 常量的声明 ...
  • DK1.5引入了新的类型——枚举。在 Java 它虽然算个“”功能,却给...现在好了,了枚举,可以把相关的常量分组到一个枚举类型里,而且枚举提供了比常量更多的方法。   Java代码  public enum Color {
  • java常用工具的使用

    热门讨论 2012-03-19 20:11:37
    而在Java类库中有一个Arrays的sort方法已经实现各种数据类型的排序算法。程序员只需要调用该的方法即可。 代码演示:Arrays实现排序 public static void main(String[] args) { int[] ages={23, 45,12,76,34,...
  • 根据上下文,java中final关键字的含义存在着细微的区别,但它通常指的是“不可改变的”不想改变可能两种理由:设计和效率,由于这两字差了很远,所以final可能被误用。 以下谈到了使用final的三种用法:数据,...
  • 、关键字概述 关键字是指特殊含义的、被保留的、不能随意使用的字符。 ...1、标识符可以包含英文字母26(区分大写)、0-9数字、$(美元符号)和_(下划线)。 2、标识符不能以数字开头。
  • java枚举常用场景

    万次阅读 2016-05-18 10:10:22
    java编程过程,我们通常需要定义一些固定数量的常量,在jdk1.5以前,通常的做法是定义一个静态常量类,但自jdk1.5后,java引入了枚举(关键字enum,全称为 enumeration,值类型),在枚举,我们可以把相关的...
  • Java中常量的分类: 1,整数常量。所有整数 2,小数常量。所有小数 3,布尔(boolean)型常量。较为特有,只有两个数值。true false。 4,字符常量。将一个数字字母或者符号用单引号( ' ' )标识。 5,字符串常量。...
  • Java小结05

    2020-03-12 19:26:59
    1.枚举 (1)定义格式 使用enum替代class (2)类中直接写常量的值 (3)enum修饰的类中都是...(1)每一个基本数据类型对应的都有一个包装类 (2)int包装类是Integer,char包装类是Character,其他的包装类都是首字母大写 (3...
  • java枚举用法

    2017-02-27 16:54:12
    Java中的枚举并不是简单常量的集合,而是一个对象。而Java中常量还包括类常量、接口常量,枚举常量什么优势呢? 2 常规方法 枚举定义 枚举类型的定义比较简单,用enum关键字加上名称和大括号包含起来的...
  • 欢迎关注专栏《Java架构筑基》——专注于Java技术的研究与分享!Java架构筑基​zhuanlan.zhihu.comJava架构筑...变量1.1 当成员变量值无需改变时,尽量定义为静态常量的每对象实例,每成员变量都有一份副...
  • Java接口知识

    2019-03-07 15:58:31
    如何定义一个接口的格式: public interface 接口名称 { // 接口内容 } 备注:换成了关键字interface之后,编译生成的字节码文件仍然是:.java --&gt; .class。 如果是Java 7,那么接口可以包含的内容: 1...
  • java书上例子6

    千次阅读 2012-12-29 12:25:33
    接口: java不支持多继承性,即一个类只能有一个父类,单继承性使得java简单,易于管理程序,为了克服单继承的缺点,java使用接口,一个类可以使用多个接口 使用 interface来定义接口 接口体包含常量定义和...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 140
精华内容 56
关键字:

java定义一个常量类中有小类

java 订阅