标签：
|
数据类型与运算符
注释
• 单行注释 用双斜线 ”//” 表示 • 多行注释 用 /*------------------*/ 表示 • 文档注释 用 /**-----------------*/ 表示 文档注释与javadoc
•文档注释还可以通过javadoc 命令来生成API文档 •格式: javadoc –d apidoc 源文件名 –其中-d path指定存放API文档的路径。 •API 文档包括三个区域分别是:包区域,类区域,详细说明区域 注: 如果要出现包区域,要让不同类处于不同的包下面才会出现包区域。
标识符和关键字
•分隔符：常见的分隔符有分号; 花括号{} 方括号[ ] 圆括号() 空格 圆点 . –在 Java 语言中每一条语句的结束用分号表示; •标识符的规则：由字母,数字,下划线_,美元$组成,但数字不能开头. •标识符不能是java的关键字和保留字,但中间可以包含标识符，不能包含空格。 •Java 的关键字加上goto const true false null 一共有53个关键字和保留字，都不能作为Java的标识符。 标识符举例
–abc_xyz √ –HelloWorld √ –abc$ √ –$中文 √ –_abc 对 √ –xyz#abc × –abc1 √ –1abc ×
数据类型的分类
•Java语言是一个强类型语言。 –所有变量，必须先声明类型，再使用。 –指定类型的变量，只能装对应的类型的数据。什么样的瓶子装什么样的酒。 •Java 语言支持的类型分为两大类: 基本数据类型和引用类型 –基本数据类型包括八大数据类型。 –引用类型包括数组、类、接口。 变量
•变量就是用来记录数据的。 •计算机内存里数据就需要通过变量来访问它。 •通俗一点，你可以把变量理解成容器，它可以装数据。 使用Scanner获取键盘输入
•使用Scanner类可以很方面地获取用户的键盘输入，Scanner是一个基于正则表达式的文本扫描器，它可以从文 件、输入流、字符串中解析出基本类型值和字符串值。Scanner类提供了多个构造器，不同的构造器可接受文件、输 入流、字符串作为数据源，用于从文件、输入流、字符串中解析数据。 •Scanner主要提供了两个方法来扫描输入： –hasNextXxx()：是否还有下一个输入项，其中Xxx可以是Int、Long等代表基本数据类型的字符串。如果 需要判断是否包含下一个字符串，则可以省略Xxx。
–nextXxx()：获取下一个输入项。Xxx的含义与前一个方法中Xxx相同。 基本数据类型
•Java 的基本数据类型可以分为两大类: boolean 类型 和 数值类型. •而数值类型又可以分为整型和浮点型 –整型包括:byte short int long（广义的整型包括char型） –在内存中各占:1,2,4,8个字节, 各有各的取值范围,略记一下。 •在定义long 类型时 必须在数字后面加L, •整数常量有三种表示方式: 十进制,八进制(以0开头),十六进制(以0x开头), 二进制（以OB开头—jdk1.7） •在java 语言中,运算过程中,整型类型默认为 int 类型 •什么样的类型的变量 只能存放什么样类型的值 浮点型
•浮点型 包括 : float 和 double 型 两种。他们分别占有4个字节和8个字节,但他们远远比int 和 long 的 4 和 8 个字节大的多
•Java 语言的浮点数有两种表示方式：十进制数形式,浮点数必须包含小数,否则系统将认为是一个int 型 如: 8.0 不能省略为: 8
•科学计数法形式： –注: 只有浮点数才有科学计数法,, •Java 语言的浮点数默认是double 型,,如果要表示float 型 必须在数字后面加 f(如：1.3f), •Java 的三个特殊的浮点数值:正无穷大,负无穷大和非数 •所有的正无穷大都是相等,负无穷大都是相等,,而非数不与任何数值相等,与自己也不相等,只有浮点数除0 才可以 得到这三个数,整数除0将报错;
数值中使用下画线分隔
•Java 7引入了一个新功能：程序员可以在数值中使用下画线，不管是整型数值，还是浮点型数值，都可以自由地 使用下画线。 •通过使用下画线分隔，可以更直观地分辨数值中到底包含多少位。
字符型
•字符也占2个字节，字符型也可当成整型用。 •字符型常量以单引号 ‘’ 括起来 •字符常量有三种表示形式: –直接通过单个字符来指定字符常: 如: ‘a’,’2’ 等 –通过转义字符: 如: ‘\n’ –直接使用Unicode 值来表示字符常量 •特别注意: 字符和字符串存在很大的区别,,字符串是以双引号括起来,而字符串则是引用类型。 boolean 类型
•boolean 类型的值只能是true 和flase •通常用在判断条件中使用boolean型 基本数据类型的类型转换
•自动类型的转换：表数范围小的自动转换为表数范围大的。 •注意: byte和short 不能和char 相互转换, 这是由于char 的取值范围是从0 到65535。,而byte 和short 中都包含 负数,所以不能相互转换。 •我们经常用到的是任何数据类型和字符串相连都会转换为字符串类型。使用 + 来连接。 强制类型转化
•强制类型转换的运算符是一对圆括号()。要将表数范围大的数据类型 转换为表数范围小的数据类型就要用()里面 写小的数据类型 •将变量转换为另一种类型。 –通常情况下,字符串不能直接转换为基本类型，如需转换使用.parseXxx(String s) 的静态方法用于将字符 串转换成基本类型。 表达式的自动提升
•如果运算中有多种类型的,表达式将结果自动提升为最大的类型。 直接量
•直接在源代码中指定的值。 •能指定直接量的只有3种类型：基本类型、字符串类型和null类型。 运算符
•算术运算符：+ , -, * / ,% ,++ ,-- –注意,自加和自减放在变量前后的区别：放在前面先完成自加和自减再把变量拿出来用,在后面先拿出来用,再自加和自减 –自加和自减只能用于操作变量,不能用于操作常量 •赋值运算符：=、+=、*=、/=、%=; •位运算符：&、 |、 ~ 、^、 << 、>>、 >>>。 •扩展后的赋值运算符 •比较运算符<、>、>=、<=、!=、== •逻辑运算符：&&、 || 、!、 ^ •三目运算符 条件? true的取值 : false 的取值 •优先级,,,尽量用小括号,,引起,这样可读性更好。
现在贴上以上知识点的代码
public class CommentTest { /* * 这里面的内容全部是多行注释 Java语言真的很有趣， */ public static void main(String[] args) { // 这是一行简单的注释 System.out.println("Hello World!"); // System.out.println("这行代码被注释了，将不会被编译、执行!"); } } //Hello World!
public class JavadocTagTest { /** * 一个得到打招呼字符串的方法。 * * @param name * 该参数指定向谁打招呼。 * @return 返回打招呼的字符串。 */ public String hello(String name) { return name + "，你好！"; } }
public class JavadocTest { /** * 简单测试成员变量 */ protected String name; /** * 主方法，程序的入口 */ public static void main(String[] args) { System.out.println("Hello World!"); } } //Hello World!
public class Test { /** * 简单测试成员变量 */ public int age; /** * Test类的测试构造器 */ public Test() { } }
public class BooleanTest { public static void main(String[] args) { boolean b1 = true; boolean b2 = false; // 下面代码将出现错误：字符串不能直接变成boolean型的值 // boolean b3 = "true"; // 使用boolean和字符串进行连接运算，boolean会自动转换成字符串 String str = true + ""; // 下面将输出true System.out.println(str); } } //true
public class CharTest { public static void main(String[] args) { // 直接指定单个字符作为字符值 char aChar = ‘a‘; // 使用转义字符来作为字符值 char enterChar = ‘\r‘; // 使用Unicode编码值来指定字符值 char ch = ‘\u9999‘; // 将输出一个‘香‘字符 System.out.println(ch); // 定义一个‘疯‘字符值 char zhong = ‘疯‘; // 直接将一个char变量当成int类型变量使用 int zhongValue = zhong; System.out.println(zhongValue); // 直接把一个0～65535范围内的int整数赋给一个char变量 char c = 97; System.out.println(c); } } //香 //30127 //a
public class FloatTest { public static void main(String[] args) { float af = 5.2345556f; // 下面将看到af的值已经发生了改变 System.out.println(af); double a = 0.0; double c = Double.NEGATIVE_INFINITY; float d = Float.NEGATIVE_INFINITY; // 看到float和double的负无穷大是相等的。 System.out.println(c == d); // 0.0除以0.0将出现非数 System.out.println(a / a); // 两个非数之间是不相等的 System.out.println(a / a == Float.NaN); // 所有正无穷大都是相等的 System.out.println(6.0 / 0 == 555.0 / 0); // 负数除以0.0得到负无穷大 System.out.println(-8 / a); // 下面代码将抛出除以0的异常 // System.out.println(0 / 0); } } //5.2345557 //true //NaN //false //true //-Infinity
public class IntegerValTest { public static void main(String[] args) { // 下面代码是正确的，系统会自动把56当成byte类型处理 byte a = 56; /* * 下面代码是错的，系统不会把9999999999999当成long类型处理， 所以超出int的表数范围，从而引起错误 */ // long bigValue = 9999999999999; // 下面代码是正确的，在巨大的整数值后使用L后缀，强制使用long类型 long bigValue2 = 9223372036854775807L; // 以0开头的整数值是8进制的整数 int octalValue = 013; System.out.println(octalValue); // 以0x或0X开头的整数值是16进制的整数 int hexValue1 = 0x13; int hexValue2 = 0XaF; System.out.println(hexValue1); System.out.println(hexValue2); // 定义二个8位的二进制数 int binVal1 = 0b11010100; byte binVal2 = 0B01101001; // 定义一个32位的二进制数,最高位是符号位。 int binVal3 = 0B10000000000000000000000000000011; System.out.println(binVal1); // 输出212 System.out.println(binVal2); // 输出105 System.out.println(binVal3); // 输出-2147483645 /* * 定义一个8位的二进制，该数值默认占32位，因此它是一个正数。 只是强制类型转换成byte时产生了溢出，最终导致binVal4变成了-23 */ byte binVal4 = (byte) 0b11101001; /* * 定义一个32位的二进制数,最高位是1。 但由于数值后添加了L后缀，因此该整数的实际占64位，第32位的1不是符号位。 * 因此binVal5的值等于2的31次方 + 2 + 1 */ long binVal5 = 0B10000000000000000000000000000011L; System.out.println(binVal4); // 输出-23 System.out.println(binVal5); // 输出2147483651 } // 11 // 19 // 175 // 212 // 105 // -2147483645 // -23 // 2147483651 }
public class UnderscoreTest { public static void main(String[] args) { // 定义一个32位的二进制数,最高位是符号位。 int binVal = 0B1000_0000_0000_0000_0000_0000_0000_0011; double pi = 3.14_15_92_65_36; System.out.println(binVal); System.out.println(pi); double height = 8_8_4_8.23; System.out.println(height); } // -2147483645 // 3.1415926536 // 8848.23 }
public class RandomStr { public static void main(String[] args) { // 定义一个空字符串 String result = ""; // 进行6次循环 for (int i = 0; i < 6; i++) { // 生成一个97～122的int型的整数 int intVal = (int) (Math.random() * 26 + 97); // 将intValue强制转换为char后连接到result后面 result = result + (char) intVal; } // 输出随机字符串 System.out.println(result); } // kvswnm }
public class PrimitiveAndString { public static void main(String[] args) { // 下面代码是错的，因为5是一个整数，不能直接赋给一个字符串 // String str1 = 5; // 一个基本类型值和字符串进行连接运算时，基本类型值自动转换为字符串 String str2 = 3.5f + ""; // 下面输出3.5 System.out.println(str2); // 下面语句输出7Hello! System.out.println(3 + 4 + "Hello！"); // 下面语句输出Hello!34，因为Hello! + 3会把3当成字符串处理， // 而后再把4当成字符串处理 System.out.println("Hello！" + 3 + 4); } // 3.5 // 7Hello！ // Hello！34 }
public class NarrowConversion { public static void main(String[] args) { int iValue = 233; // 强制把一个int类型的值转换为byte类型的值 byte bValue = (byte) iValue; // 将输出-23 System.out.println(bValue); double dValue = 3.98; // 强制把一个double类型的值转换为int int tol = (int) dValue; // 将输出3 System.out.println(tol); } // -23 // 3 }
public class AutoPromote { public static void main(String[] args) { // 定义一个short类型变量 short sValue = 5; // 下面代码将出错：表达式中的sValue将自动提升到int类型， // 则右边的表达式类型为int，将一个int类型赋给short类型的变量将发生错误。 // sValue = sValue - 2; byte b = 40; char c = ‘a‘; int i = 23; double d = .314; // 右边表达式中在最高等级操作数为d（double型） // 则右边表达式的类型为double型,故赋给一个double型变量 double result = b + c + i * d; // 将输出144.222 System.out.println(result); int val = 3; // 右边表达式中2个操作数都是int，故右边表达式的类型为int // 因此，虽然23/3不能除尽，依然得到一个int整数 int intResult = 23 / val; System.out.println(intResult); // 将输出7 // 输出字符串Hello!a7 System.out.println("Hello!" + ‘a‘ + 7); // 输出字符串104Hello! System.out.println(‘a‘ + 7 + "Hello!"); } // 144.222 // 7 // Hello!a7 // 104Hello! }
public class AutoConversion { public static void main(String[] args) { int a = 6; // int可以自动转换为float类型 float f = a; // 下面将输出6.0 System.out.println(f); // 定义一个byte类型的整数变量 byte b = 9; // 下面代码将出错，byte型不能自动类型转换为char型 // char c = b; // 下面是byte型变量可以自动类型转换为double型 double d = b; // 下面将输出9.0 System.out.println(d); } // 6.0 // 9.0 }
public class AssignOperatorTest { public static void main(String[] args) { String str = "Java"; // 为变量str赋值为Java double pi = 3.14; // 为变量pi赋值为3.14 boolean visited = true; // 为变量visited赋值为true String str2 = str; // 将变量str的值赋给str2 int a; int b; int c; // 通过为a, b , c赋值，三个变量的值都是7 a = b = c = 7; // 输出三个变量的值。 System.out.println(a + "\n" + b + "\n" + c); double d1 = 12.34; double d2 = d1 + 5; // 将表达式的值赋给d2 System.out.println(d2); // 输出d2的值，将输出17.34 } // 7 // 7 // 7 // 17.34 }
public class BitOperatorTest { public static void main(String[] args) { // System.out.println(2.5 & 3.0); System.out.println(5 & 9); // 将输出1 System.out.println(5 | 9); // 将输出13 System.out.println(~-5); // 将输出4 System.out.println(5 ^ 9); // 将输出12 System.out.println(5 << 2); // 输出20 System.out.println(-5 << 2); // 输出-20 System.out.println(-5 >> 2); // 输出-2 System.out.println(-5 >>> 2); // 输出1073741822 } // 1 // 13 // 4 // 12 // 20 // -20 // -2 // 1073741822 }
//比较运算符 public class ComparableOperatorTest { public static void main(String[] args) { System.out.println("5是否大于 4.0：" + (5 > 4.0)); // 输出true System.out.println("5和5.0是否相等：" + (5 == 5.0)); // 输出true System.out.println("97和‘a‘是否相等：" + (97 == ‘a‘)); // 输出true System.out.println("true和false是否相等：" + (true == false)); // 输出false // 创建2个ComparableOperatorTest对象，分别赋给t1和t2两个引用 ComparableOperatorTest t1 = new ComparableOperatorTest(); ComparableOperatorTest t2 = new ComparableOperatorTest(); // t1和t2是同一个类的两个实例的引用，所以可以比较， // 但t1和t2引用不同的对象，所以返回false System.out.println("t1是否等于t2：" + (t1 == t2)); // 直接将t1的值赋给t3，即让t3指向t1指向的对象 ComparableOperatorTest t3 = t1; // t1和t3指向同一个对象，所以返回true System.out.println("t1是否等于t3：" + (t1 == t3)); } // 5是否大于 4.0：true // 5和5.0是否相等：true // 97和‘a‘是否相等：true // true和false是否相等：false // t1是否等于t2：false // t1是否等于t3：true }
public class DivTest { public static void main(String[] args) { double a = 5.2; double b = 3.1; double div = a / b; // div的值将是1.6774193548387097 System.out.println(div); // 输出正无穷大：Infinity System.out.println("5除以0.0的结果是:" + 5 / 0.0); // 输出负无穷大：-Infinity System.out.println("-5除以0.0的结果是:" + -5 / 0.0); // 下面代码将出现异常 // java.lang.ArithmeticException: / by zero System.out.println("-5除以0的结果是::" + -5 / 0); } // 1.6774193548387097 // 5除以0.0的结果是:Infinity // -5除以0.0的结果是:-Infinity // Exception in thread "main" java.lang.ArithmeticException: / by zero // at DivTest.main(DivTest.java:26) }
public class EnhanceAssignTest { public static void main(String[] args) { // 定义一个byte类型的变量 byte a = 5; // 下面语句出错，因为5默认是int类型，a + 5就是int类型。 // 把int类型赋给byte类型的变量，所以出错 // a = a + 5; // 定义一个byte类型的变量 byte b = 5; // 下面语句不会出现错误 b += 5; } }
public class LogicOperatorTest { public static void main(String[] args) { // 直接对false求非运算，将返回true System.out.println(!false); // 5>3返回true，‘6‘转换为整数54，‘6‘>10返回true，求与后返回true System.out.println(5 > 3 && ‘6‘ > 10); // 4>=5返回false，‘c‘>‘a‘返回true。求或后返回true System.out.println(4 >= 5 || ‘c‘ > ‘a‘); // 4>=5返回false，‘c‘>‘a‘返回true。两个不同的操作数求异或返回true System.out.println(4 >= 5 ^ ‘c‘ > ‘a‘); // 定义变量a,b，并为两个变量赋值 int a = 5; int b = 10; // 对a > 4和b++ > 10求或运算 if (a > 4 | b++ > 10) { // 输出a的值是5，b的值是11。 System.out.println("a的值是:" + a + "，b的值是:" + b); } // 定义变量c,d，并为两个变量赋值 int c = 5; int d = 10; // c > 4 || d++ > 10求或运算 if (c > 4 || d++ > 10) { // 输出c的值是5，d的值是10。 System.out.println("c的值是:" + c + "，d的值是:" + d); } } // true // true // true // true // a的值是:5，b的值是:11 // c的值是:5，d的值是:10 }
public class MathTest { public static void main(String[] args) { double a = 3.2; // 定义变量a为3.2 // 求a的5次方，并将计算结果赋为b。 double b = Math.pow(a, 5); System.out.println(b); // 输出b的值。 // 求a的平方根，并将结果赋给c double c = Math.sqrt(a); System.out.println(c); // 输出c的值。 // 计算随机数,返回一个0～1之间的伪随机数。 double d = Math.random(); System.out.println(d); // 输出随机数d的值 // 求1.57的sin函数值：1.57被当成弧度数 double e = Math.sin(1.57); System.out.println(e); // 输出接近1 } // 335.5443200000001 // 1.7888543819998317 // 0.009123308804006247 // 0.9999996829318346 }
public class ModTest { public static void main(String[] args) { double a = 5.2; double b = 3.1; double mod = a % b; System.out.println(mod); // mod的值为2.1 System.out.println("5对0.0求余的结果是:" + 5 % 0.0); // 输出非数:NaN System.out.println("-5.0对0求余的结果是:" + -5.0 % 0); // 输出非数:NaN System.out.println("0对5.0求余的结果是:" + 0 % 5.0); // 输出0.0 System.out.println("0对0.0求余的结果是:" + 0 % 0.0); // 输出非数:NaN // 下面代码将出现异常：java.lang.ArithmeticException: / by zero System.out.println("-5对0求余的结果是:" + -5 % 0); } // 2.1 // 5对0.0求余的结果是:NaN // -5.0对0求余的结果是:NaN // 0对5.0求余的结果是:0.0 // 0对0.0求余的结果是:NaN // Exception in thread "main" java.lang.ArithmeticException: / by zero // at ModTest.main(ModTest.java:25) }
public class ThreeTest { public static void main(String[] args) { String str = 5 > 3 ? "5大于3" : "5不大于3"; System.out.println(str); // 输出"5大于3" String str2 = null; if (5 > 3) { str2 = "5大于3"; } else { str2 = "5不大于3"; } int a = 11; int b = 12; // 三目运算符支持嵌套 System.out.println(a > b ? "a大于b" : (a < b ? "a小于b" : "a等于b")); } // 5大于3 // a小于b }
|
标签：
原文地址：http://www.cnblogs.com/pipi-changing/p/5399699.html
