标签：JAVA 复习 int System String println public Restart out

作为22届专科生，在没有经历和学历的情况下找一份得体的工作  是多么“奢侈”，世上岂无千里马,人中难得九方皋.

废话太多我们开始吧！

JAVA从这里开始

 

Java的历史（不感兴趣直接跳过）

Java 的历史要追溯到 1991 年，项目“Green”启动！帕特里克、詹姆斯·高斯林、麦克·舍林丹和其他几个工程师专攻计算机在家电产品上的嵌入式应用，OaK语言问世

1992 年， Green 项目发了第一个产品，这个产品可以提供非常智能的远程控制，遗憾的是， Sun 公司对这个产品并不感兴趣

1993 年，Green 项目（新名字 “First Person 公司”)

1994年， 一直苦苦寻求买家购买他们的技术。 然后一个也没有找到， 然后Frist Person 公司解散了。

1995年，HotJava 浏路器问世，Java Applet“技术证明” 引发了人们对他的追逐，超过了 10 万人下载 Java 语言。OAK正式改名Java

1996 年， Sun 发布了第一个 Java 1.0 版本。 但是这个版本 Java 1.0 并不能用来进行真正的应用开发

1997年，发布jdk1.1，实现三周内22万人次下载。

/*
*JDK 1.1 引入的新特性包括：
*
*引入JDBC（Java Database Connectivity）；
*支持内部类；
*引入Java Bean；
*引入RMI（Remote Method Invocation）；
*引入反射（仅用于内省）。
*/

1998 年 JavaOne 会议的头号新闻就是发布 Java 1.2 版本， 将这个早期玩具式的 GUI 和图形工具包括一些工具包。 在这个版本发布的 3 天后, Sun 公司的市场部将它改名为更加吸引人的 “Java 2 标准版软件开发 1.2 版”。除了标准版（Standard Edition）J2SE 之外， Sun 公司还推出了另外两个版本： 一是， 手机嵌入式设备“微型版”（Micro Edition）J2ME。另一个是用于服务器端的处理“企业版”（Enterprise Edition）J2EE。

/*
*JDK 1.2 开发代号为Playground（操场）
*
*引入的新特性包括：
*
*引入集合（Collection）框架；
*
*对字符串常量做内存映射；
*
*引入JIT（Just In Time）编译器；
*
*引入对打包的Java文件进行数字签名；
*
*引入控制授权访问系统资源的策略工具；
*
*引入JFC（Java Foundation Classes），包括Swing 1.0、拖放和Java 2D类库；
*
*引入Java 插件；
*
*在JDBC中引入可滚动结果集、BLOB、CLOB、批量更新和用户自定义类型；
*
*在Applet中添加声音支持。
*/

1999 年 4 月 27 日， HotSpot 虚拟机发布。

2000 年 5 月 8 日， J2SE 1.3 发布

/*
*JDK 1.3   开发代号为Kestrel（红隼）
*
*引入的新特性包括：
*
*引入Java Sound API；
*
*jar文件索引；
*
*对Java的各个方面都做了大量优化和增强。
*/

2001 年 9 月 24 日， J2EE 1.3 发布

2002 年 2 月 26 日， J2SE 1.4 发布

/*
*JDK 1.4  开发代号为Merlin（隼）
*
*引入的新特性包括:
*
*XML处理；
*
*Java打印服务；
*
*引入Logging API；
*
*引入Java Web Start；
*
*引入JDBC 3.0 API；
*
*引入断言；
*
*引入Preferences API；
*
*引入链式异常处理；
*
*支持IPv6；
*
*支持正则表达式；
*
*引入Image I/O slot machine API。
*/

2004 年 9 月 30 日， 下午 18：00， J2SE 1.5 发布，增加了几个很有用的语言特性： for each 循环、自动装箱、注解、枚举、可变长参数等。

/*
*JDK 1.5  开发代号为Tiger（老虎）
*
*引入的新特性包括:
*
*引入泛型；
*
*增强循环，可以使用迭代方式；
*
*自动装箱与自动拆箱；
*
*类型安全的枚举；
*
*可变参数；
*
*静态引入；
*
*元数据（注解）；
*
*引入Instrumentation。
*/

2005 年 6 月，JavaOne 大会召开，Sun 公司公开 Java SE 6。并且，对 Java 的各种版本进行更名，取消其中的数字“2”：J2EE 改名为 Java EE

2006 年 12 月， Sun 公司发布了 Java EE 6，， 并且宣布， 将 Java 语言作为免费软件对外发布。

/*
*JDK 1.6  开发代号为Mustang（野马）
*
*引入的新特性包括：
*
*支持脚本语言；
*
*引入JDBC 4.0 API；
*
*引入Java Compiler API；
*
*可插拔注解；
*
*增加对Native PKI(Public Key Infrastructure)、Java GSS(Generic Security Service)、Kerberos和LDAP(Lightweight Directory Access Protocol)的支持；
*
*继承Web Services；
*
*做了很多优化。
*/

2009年 　Oracle 以 74 亿美元收购 Sun 公司，Java 的开发停滞了一段时间。一直到了 2011 年

2011 年 7 月，JavaSE 7 发布。但是很多规划在这个版本的特性，其中 Lambda 项目 ( Lambda 表达式、函数式编程)、Jigsaw 项目(虚拟机模块化支持)、动态语言支持、GarbageFirst 收集器和 Coin 项目(语言细节进化)等子项目都没有实现在这个版本中， 而是用了 Oracle 公司实行的 “B计划”。

/*
*JDK 1.7  开发代号是Dolphin（海豚）
*
*引入的新特性包括：
*
*switch语句块中允许以字符串作为分支条件；
*
*在创建泛型对象时应用类型推断；
*
*在一个语句块中捕获多种异常；
*
*支持动态语言；
*
*支持try-with-resources；
*
*引入Java NIO.2开发包；
*
*数值类型可以用2进制字符串表示，并且可以在字符串表示中添加下划线；
*
*钻石型语法；
*
*null值的自动处理。
*
*/

2014 年 3 月，JavaSE 8 发布。 这个版本， 在近 20 年中这个版本变更最大， Java SE 8 包含了 “函数式” 编程方式，可以很容易的表述并发执行的计算。 这个版本也是现在企业中使用范围最广的一个版本。

/*
*JDK 1.8  开发代号是Spider（蜘蛛）
*
*支持 lambda支持；
*
*增强日期与时间API的功能；
*
*对垃圾回收的性能也进行了改进；
*
*并且移除了permgen区。
*
*Lambdas表达式与Functional接口
*
*接口的默认与静态方法
*
*方法引用
*
*重复注解
*
*更好的类型推测机制
*
*扩展注解的支持
*/

2017 年 7 月，Oracle 公司将发布 JDK 9。这个版本算是比较大的调整，加入了很早之前就规划的模块化功能。并且对整个 JDK 基于模块进行了重新编写。

从 2018 年开始， 每6个月就会发布一个 Java 版本， 以更快地引入新特性

/*
*2018 年 3 月 21 日， Java 10 发布。
*
*2018 年 9 月 25 日， Java 11 LTS 发布。 
*
*2019 年 2 月 Java 12 发布 
*
*2019 年 9 月 Java 13 发布
*
*2020 年 3 月 17 日，Java 14 发布。
*
*2020 年 9 月 15 日，Java 15 发布。
*
*2021 年 3 月 16 日，Java SE 16 发布。
*
*2021 年 9 月 14 日，Java SE 17 LTS 发布。
*/

这个是继 Java 11 之后的有一个长期支持版本， 并且直接支持到了 2029 年 9 月。这可能是下一个 Java 8。

注意：大多数人安装Java的时候都会被指引安装Java SE，而非OpenJDK。 不要去甲骨文下载页面下载！！

Hello World

1 public class HelloWorld {
2     /* 
       *输出字符串 Hello World
4      */
5     public static void main(String[] args) {
6         System.out.println("Hello World"); 
7     //控制台 输出 Hello World
8     }
9 }

 

 

 

/*
*编写 Java 程序时，应注意以下几点：
*
*1·大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
*2·类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
*3·方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
*4·源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
*5·主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
*/

命名规范

/*
*所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
*首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
*关键字不能用作标识符
*标识符是大小写敏感的
*合法标识符举例：age、$salary、_value、__1_value
*非法标识符举例：123abc、-salary
*/

　Java运行源程序和编译型的区别

 

 

 Java的对象和类

 

 用代码表示及是：

类（狗类）

1  public class Dog {
2     //构造
3      Public Dog(){}
4      Public Dog(String name){}   
5 
6 }    

这里有注意点（一个源文件中只能有一个 public 类），及以下是错误行为

 1 public class Dog {
 2       Public Dog(){}
 3       Public Dog(String name){}   
 4  
 5  }    
 6 public class Cat{
 7       Public Dog(){}
 8       Public Dog(String name){}   
 9  
10  }  

这种错误没人会出（作者：“其实就是告诉你源文件是什么”），讲个冷笑话，我们继续！

对象（狗对象）

 1 public class Dog{
 2    public Dog(String  name){
 3       //这个构造器仅有一个参数：name
 4       System.out.println("小狗的名字是 : " + name ); 
 5    }
 6    public static void main(String[] args){
 7       // 下面的语句将创建一个Dog对象
 8       Dog LonelyDog = new Dog( "单身狗" );
 9    }
10 }

访问实例变量和方法（开发中常用）

1 /* 实例化对象 */
2 Object DogA= new Dog();
3 /* 访问类中的变量 */
4 DogA.name;
5 /* 访问类中的方法 */
6 DogA.eat();

初学不要着急（看不懂也正常），后面我们还有详解（项目实战中）

Java 包

包主要用来对类和接口进行分类。当开发 Java 程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。（项目实战中，详解）

import 语句

import java.io.*;
//就是引入一个类（前端后端都很常见）
//import + 相对路径或结对路径

相对路径：以引用文件所在位置为参考基础，而建立的目标路径

 

 绝对路径：指是某个目录或者网站的绝对位置

 

 

　

Java 基本数据类型

面试官：Java有几大数据类型？

我：8种 （byte short int long float double boolean char ）

正确答案：两种，内置数据类型（基本数据类型）和引用数据类型

面试官（这小子基础不是很牢靠！我再往深问问，早点达标好清闲）：创建一个变量来储存手机号，你会用的什么类型？

我：Integer（哦买的娃蒙西的有）

解释：Integer最大值是 2,147,483,647（没错，10位数）

面试官：表现挺好的，你先回去等通知吧（另谋高就吧）

博客园，学习，记笔记非常好用，而且可以自己设计喜欢的皮肤（主要是免费！免费！免费！）这不赶紧用起来（顺便关注一下作者，批评一下也行，欸嘿）

下面是些常识不用刻意记（最大值最小值其实就是 二进制位数 取最大值 除二  余数给负数）

例如：   byte  二进制位数：8 11111111（最大）

　　　　11111111 转换10进制就是 255

　　　　255/2=127....1

　　　　及最大值为127 最小值为 -128（以此类推）

 

 1 基本类型：byte 二进制位数：8
 2 包装类：java.lang.Byte
 3 最小值：Byte.MIN_VALUE=-128
 4 最大值：Byte.MAX_VALUE=127
 5 
 6 基本类型：short 二进制位数：16
 7 包装类：java.lang.Short
 8 最小值：Short.MIN_VALUE=-32768
 9 最大值：Short.MAX_VALUE=32767
10 
11 基本类型：int 二进制位数：32
12 包装类：java.lang.Integer
13 最小值：Integer.MIN_VALUE=-2147483648
14 最大值：Integer.MAX_VALUE=2147483647
15 
16 基本类型：long 二进制位数：64
17 包装类：java.lang.Long
18 最小值：Long.MIN_VALUE=-9223372036854775808
19 最大值：Long.MAX_VALUE=9223372036854775807
20 
21 基本类型：float 二进制位数：32
22 包装类：java.lang.Float
23 最小值：Float.MIN_VALUE=1.4E-45
24 最大值：Float.MAX_VALUE=3.4028235E38
25 
26 基本类型：double 二进制位数：64
27 包装类：java.lang.Double
28 最小值：Double.MIN_VALUE=4.9E-324
29 最大值：Double.MAX_VALUE=1.7976931348623157E308
30 
31 基本类型：char 二进制位数：16
32 包装类：java.lang.Character
33 最小值：Character.MIN_VALUE=0
34 最大值：Character.MAX_VALUE=65535

JAVA中还存在另外一种基本类型 void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

 

 转义字符

 

 

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

byte,short,char—> int —> long—> float —> double
注意：浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

 1 public class ZiDongLeiZhuan{
 2         public static void main(String[] args){
 3             char c1='a';//定义一个char类型
 4             int i1 = c1;//char自动类型转换为int
 5             System.out.println("char自动类型转换为int后的值等于"+i1);
 6             char c2 = 'A';//定义一个char类型
 7             int i2 = c2+1;//char 类型和 int 类型计算
 8             System.out.println("char类型和int计算后的值等于"+i2);
 9         }
10 }

强制类型转换

public class QiangZhiZhuanHuan{
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}

隐含强制类型转换

1、 整数的默认类型是 int。

2. 小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f。

Eg: short numOne=1;
　　 numTwo=numOne+1;//这时就会编译报错 （short）（numOne+1)解决

 

Java 变量类型

有人问我什么人都可以学Java吗？英语不好可以吗？。。。。作者英语也不好不照样学，不过英语好的 的却更学的快，不废话，我们继续。

直接上实例：

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

变量又分为 类变量 、实例变量 、局部变量

词穷了直接上代码

 1 public class Variable{
 2      // 类变量  ，静态static修饰  
 3     static int allClicks=0;   
 4      //String是实例
 5     String str="hello world";  // 实例变量
 6  
 7     public void method(){
 8         //在方法内，外边无法直接调用
 9         int i =0;  // 局部变量
10  
11     }
12 }

 

Java 修饰符

分为以下两类 访问修饰符 和 非访问修饰符

访问控制修饰符

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private（其他类不能访问） : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

　　私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且　　　　       类和接口不能声明为 private。声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。　　　　　　       Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据

       

public（所有的类都能够访问） : 对所有类可见。使用对象：类、接口、变量、方法

protected （仅子类可见）: 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

（面向对象会详解以下）

• 父类中声明为 public 的方法在子类中也必须为 public。

• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。

• 父类中声明为 private 的方法，不能够被子类继承。

内部类外部类

 1 public class Outer {
 2     //外部类
 3     int x = 9;
 4     class Inner{
 5         //内部类 6         int x = 8;
 7         public void test(){
 8             int x = 7;
 9             System.out.println(x);
10             System.out.println(this.x);
11             System.out.println(Outer.this.x); //这里展示了三种不同的访问及其对应的结果
12             test1();
13         }
14     }
15 
16     private void test1(){
17         System.out.println("test");
18     }
19     public static void main(String[] args) {//外调内
20         Inner in = new Outer().new Inner();
21         in.test();
22     }
23 }

 

非访问修饰符

static 修饰符，用来修饰类方法和类变量（静态变量，静态方法）。对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问
静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
注意：static修饰的方法，在类加载的时候是被首先加载的，然后加载非static内容，所以加载static时 是不知道非static内容的

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
final 类不能被继承，没有类能够继承 final 类的任何特性

abstract 修饰符，用来创建抽象类和抽象方法。
　抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被 abstract和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

 

　任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是，抽象类抽象类可以不包含抽象方法
synchronized 和 volatile 修饰符，主要用于线程的编程。

　　synchronized 同一时间只能被一个线程访问，修饰符可以应用于四个访问修饰符

　　volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值，这样两个不同的线程总是看到某个成员变量的同一个值，

 1 //Eg：
 2 
 3 public class MyRunnable implements Runnable
 4 
 5 {
 6 
 7 　　private volatile boolean active;
 8 
 9 　　public void run()
10 
11 　　　　 {
12 
13   　　　　　　active = true;
14 
15 　　　　　　　while (active) // 第一行 { // 代码 }
16 
17 　　　　　　　　　　}
18 
19 　　　　public void stop() { active = false; // 第二行 }
20 
21 }

 

抽象类和方法（可以了解一下，后面详解）

abstract class Caravan{
   //抽象类
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

Java 运算符

我们常用的运算符有 算术运算符、 关系运算符、 位置运算符 、逻辑运算符、 赋值运算符等

算术运算符

 

 

 

前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。

后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算（看以下实例）

 1 public static void main(String[] args) {
 2      int a = 10;
 3      int b = 25;
 4      
 5      System.out.println("a++   = " +  (a++) );
 6      System.out.println("a--   = " +  (a--) );
 7      // 查看  d++ 与 ++d 的不同
 8      System.out.println("d++   = " +  (d++) );
 9      System.out.println("++d   = " +  (++d) );
10   }
11 
12 /*a++   = 10
13 * a--   = 11
14 * d++   = 25
15 * ++d   = 27
16 */

关系运算符

位运算符

这些，不是很常见的内容

 

 

 以下为实例

public class Test {
  public static void main(String[] args) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c );
 
     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );
 
     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );
 
     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );
 
     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c );
 
     c = a >> 2;     /* 15 = 1111 */
     System.out.println("a >> 2  = " + c );
  
     c = a >>> 2;     /* 15 = 0000 1111 */
     System.out.println("a >>> 2 = " + c );
  }
} 

结果：
*a & b = 12

a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15

逻辑运算符

 

 

 

 

赋值运算符

 

 

 

条件运算符（?:）

这个过几篇就能频繁看到了！！ 

直接看代码：

 1 public class Test {
 2    public static void main(String[] args){
 3       int a , b;
 4       a = 10;
 5       // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
 6       b = (a == 1) ? 20 : 30;
 7       System.out.println( "Value of b is : " +  b );
 8  
 9       // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
10       b = (a == 10) ? 20 : 30;
11       System.out.println( "Value of b is : " + b );
12    }
13 }
//Value of b is : 30

//Value of b is : 20

instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

Java运算符优先级

 

 

 

Java 循环结构 - for, while 及 do...while

后端日常开发内容就是这些（说好听点叫业务，哈哈）

while 循环

public class Test {
    //while( 布尔表达式 ) {
   //循环内容
   //}
   public static void main(String[] args) {
      int x = 10;
      while( x < 20 ) {
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }
   }
}

do…while 循环

public class Test {

/*do {
 *代码语句
 *}while(布尔表达式);
 */

   public static void main(String[] args){
      int x = 10;
 
      do{
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }while( x < 20 );
   }
}

for循环

public class Test {
   public static void main(String[] args) {
       /* for(初始化; 布尔表达式; 更新) {
        *代码语句
        * }
        */
      for(int x = 10; x < 20; x = x+1) {
         System.out.print("value of x : " + x );
         System.out.print("\n");
      }
   }
}        

Java 增强 for 循环

 1 public class Test {
 2    public static void main(String[] args){
 3         /*for(声明语句 : 表达式)
 4          *{
 5           *代码句子
 6           *}
 7           */
 8       int [] numbers = {10, 20, 30, 40, 50};
 9  
10       for(int x : numbers ){
11          System.out.print( x );
12          System.out.print(",");
13       }
14       System.out.print("\n");
15       String [] names ={"James", "Larry", "Tom", "Lacy"};
16       for( String name : names ) {
17          System.out.print( name );
18          System.out.print(",");
19       }
20    }
21 }   
//结果：

//10,20,30,40,50,
//James,Larry,Tom,Lacy,

break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

 1 public class Test {
 2    public static void main(String[] args) {
 3       int [] numbers = {10, 20, 30, 40, 50};
 4  
 5       for(int x : numbers ) {
 6          // x 等于 30 时跳出循环
 7          if( x == 30 ) {
 8             break;
 9          }
10          System.out.print( x );
11          System.out.print("\n");
12       }
13    }
14 }
//结果：10
//　　　20

continue 关键字

跳转到下一次循环的迭代

 1 public class Test {
 2    public static void main(String[] args) {
 3       int [] numbers = {10, 20, 30, 40, 50};
 4  
 5       for(int x : numbers ) {
 6          if( x == 30 ) {
 7         continue;
 8          }
 9          System.out.print( x );
10          System.out.print("\n");
11       }
12    }
13 }
14 
15 /*以上实例编译运行结果如下：
16 
17 *10
18 *20
19 *40
20 *50
21 */

 

Java 条件语句 - if...else

if(布尔表达式) { //如果布尔表达式为true将执行的语句 }else{//false执行}

public class Test {
 
   public static void main(String args[]){
      int x = 30;
 
      if( x < 20 ){
         System.out.print("这是 if 语句");
      }else{
         System.out.print("这是 else 语句");
      }
   }
}

//以上代码编译运行结果如下：

//这是 else 语句

if...else if...else 语句

1 if(布尔表达式 1){
2    //如果布尔表达式 1的值为true执行代码
3 }else if(布尔表达式 2){
4    //如果布尔表达式 2的值为true执行代码
5 }else if(布尔表达式 3){
6    //如果布尔表达式 3的值为true执行代码
7 }else {
8    //如果以上布尔表达式都不为true执行代码
9 }

switch case 语句

 1 switch(expression){
 2     case value :
 3        //语句
 4        break; //可选
 5     case value :
 6        //语句
 7        break; //可选
 8     //你可以有任意数量的case语句
 9     default : //可选
10        //语句
11 }

 

 如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case 的值都会输出。

 1 public class Test {
 2    public static void main(String args[]){
 3       int i = 1;
 4       switch(i){
 5          case 0:
 6             System.out.println("0");
 7          case 1:
 8             System.out.println("1");
 9          case 2:
10             System.out.println("2");
11          case 3:
12             System.out.println("3"); break;
13          default:
14             System.out.println("default");
15       }
16    }
17 }
18 
19 /*以上代码编译运行结果如下：
20 
21 *1
22 *2
23 *3
24 */

 

Java Number & Math 类

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、float、long、double 等。

 

 

 

 

 

 

Number & Math 类方法

xxxValue() 方法

 

 

 

 1 public class Test{ 
 2  
 3    public static void main(String args[]){
 4       Integer x = 5;
 5       // 返回 byte 原生数据类型
 6       System.out.println( x.byteValue() );
 7  
 8       // 返回 double 原生数据类型
 9       System.out.println(x.doubleValue());
10  
11       // 返回 long 原生数据类型
12       System.out.println( x.longValue() );      
13    }
14 }
15 
16 编译以上程序，输出结果为：
17 5
18 5.0
19 5

compareTo() 方法

compareTo() 方法用于将 Number 对象与方法的参数进行比较。可用于比较 Byte, Long, Integer等

public class Test{ 
   public static void main(String args[]){
      Integer x = 5;
      System.out.println(x.compareTo(3));
      System.out.println(x.compareTo(5));
      System.out.println(x.compareTo(8));            
     }
}

//如果指定的数与参数相等返回 0。
//如果指定的数小于参数返回 -1。
//如果指定的数大于参数返回 1。

编译以上程序，输出结果为：

1
0
-1

equals() 方法

equals 是建立在引用类型上的比较,==常用于比较原生类型，对象不多见(equals不重写的话和==作用是一样的)

1）对于==，比较的是值是否相等

如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

如果作用于引用类型的变量，则比较的是所指向的对象的地址

2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量，equals继承Object类，比较的是是否是同一个对象

如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

 1 public class Test{
 2         public static void main(String args[]){
 3                 Integer x = 5;
 4                 Integer y = 10;
 5                 Integer z =5;
 6                 Short a = 5;
 7 
 8                 System.out.println(x.equals(y));  
 9                 System.out.println(x.equals(z));
10                 System.out.println(x.equals(a));
11         }
12 }
13 
14 
15 编译以上程序，输出结果为：
16 
17 false
18 true
19 false

valueOf() 方法

valueOf() 方法用于返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等。

开发中常常用来转换16进制10进制等等

public class Test{
public static void main(String args[]){
                Integer x =Integer.valueOf(9);
                Double c = Double.valueOf(5);
                Float a = Float.valueOf("80");              

                Integer b = Integer.valueOf("444",16);   // 使用 16 进制

                System.out.println(x);
                System.out.println(c);
                System.out.println(a);
                System.out.println(b);
        }
}

 

toString() 方法

toString() 方法用于返回以一个字符串表示的 Number 对象值。

parseInt() 方法

parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析。

 1 public class Test{
 2     public static void main(String args[]){
 3         int x =Integer.parseInt("9");
 4         double c = Double.parseDouble("5");
 5         int b = Integer.parseInt("444",16);
 6 
 7         System.out.println(x);
 8         System.out.println(c);
 9         System.out.println(b);
10     }
11 }

编译以上程序，输出结果为：9、5.0、1092

9
5.0
1092

random() 方法

random() 方法用于返回一个随机数，随机数范围为 0.0 =< Math.random < 1.0。

public class Test{
    public static void main(String args[]){
        System.out.println( Math.random() );
        System.out.println( Math.random() );
    }
}


编译以上程序，输出结果为：

0.5444085967267008
0.7960235983184115

不常用

 

 面试几率问道的（怎么说....精度大的不用，小的用不着...）

 

 

Character 类

开发中工具类里有时看到，用处一般是按条件分割单词 插入符号等等（这个类起到一个判断作用）

 

Java 数组

为什么数组在String类前？哈哈不要着急，String类本质也是数组

1 dataType[] arrayRefVar;   // 首选的方法
2  
3 或
4  
5 dataType arrayRefVar[];  // 效果相同，但不是首选方法

示例：
double[] myList;         // 首选的方法
 
或
 
double myList[];         //  效果相同，但不是首选方法

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

总和为： 11367.373

//二维数组 
String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

Arrays 类

 

 

String 类

创建字符

String s1 = "Runoob";              // String 直接创建
String s2 = "Runoob";              // String 找到并指向Runoob
String s3 = s1;                        // 相同引用
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建

 

 

charAt() 方法

charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。

public class Test {
    public static void main(String args[]) {
        String s = "www.runoob.com";
        char result = s.charAt(6);
        System.out.println(result);
    }
}


以上程序执行结果为：

n

compareTo()

先看代码吧

public class Test {
 
    public static void main(String args[]) {
        String str1 = "Strings";
        String str2 = "Strings";
        String str3 = "Strings123";
 
        int result = str1.compareTo( str2 );
        System.out.println(result);
      
        result = str2.compareTo( str3 );
        System.out.println(result);
     
        result = str3.compareTo( str1 );
        System.out.println(result);
    }
}
以上程序执行结果为：

0
-3
3

如果第一个字符和参数的第一个字符不等，结束比较，返回第一个字符的ASCII码差值。

如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至不等为止，返回该字符的ASCII码差值。 如果两个字符串不一样长，可对应字符又完全一样，则返回两个字符串的长度差值。

是不是又陌生又熟悉？？，哈哈，那么问题来了“Math的compareTo和String的又什么区别？？”

math的本质是比较大小 string的就复杂一些他会根据ASCII码判断不过大同小异

 

compareToIgnoreCase() 方法和compareTo不同之处就是判断的时候不区分大小写字母

concat() 方法

面试官：concat和+的区别又内些

你：+可以计算concat是字符串连接用的

面试官：听君一席话如听一席话！

其实 两者性能上没有很大区别，本质上都是使用StringBuffer()在堆（先记一下，这些在JVM详解）开辟一个空间最后调用to String方法转换为String对象，concat只能接收字符串，而+可以是字符串或者数字及其他基本类型数据。通常我们“+”即可，+左右可以为null，concat会报空指针，凡是方法都有这个通病如果拼接空字符串concat会稍快，毕竟+运行的代码要多一点（可以忽略不计），注意代码的出错率的建议“+”，更注重性能的用concat。

 

contentEquals() 方法

contentEquals() 方法用于将此字符串与指定的 StringBuffer 比较。

 copyValueOf() 方法

将指定字符数组中的所有字符复制到一个新的字符数组中，并返回一个新的字符串。该方法与 String 类中的 valueOf(char[] data) 方法非常相似，有两个重载形式，其中一个允许您指定要从输入数组中复制的起始位置和要复制的字符数：

public static String copyValueOf(char[] data): 返回指定数组中表示该字符序列的字符串。

public static String copyValueOf(char[] data, int offset, int count): 返回指定数组中表示该字符序列的字符串。

endsWith() 方法

endsWith() 方法用于测试字符串是否以指定的后缀结束。

 1 public class Test {
 2     public static void main(String args[]) {
 3         String Str = new String("菜鸟教程：www.runoob.com");
 4         boolean retVal;
 5  
 6         retVal = Str.endsWith( "runoob" );
 7         System.out.println("返回值 = " + retVal );
 8  
 9         retVal = Str.endsWith( "com" );
10         System.out.println("返回值 = " + retVal );
11     }
12 }

 startsWith() 方法

startsWith() 方法用于检测字符串是否以指定的前缀开始。

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.runoob.com");
 
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("www") );
 
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("runoob") );
 
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("runoob", 4) );
    }
}
以上程序执行结果为：

返回值 :true
返回值 :false
返回值 :true

 

equals() 方法

equals() 方法用于将字符串与指定的对象比较。

String 类中重写了 equals() 方法用于比较两个字符串的内容是否相等。

 

String s1 = "Hello";              // String 直接创建
String s2 = "Hello";              // String 直接创建
String s3 = s1;                   // 相同引用
String s4 = new String("Hello");  // String 对象创建
String s5 = new String("Hello");  // String 对象创建
 
s1 == s1;         // true, 相同引用
s1 == s2;         // true, s1 和 s2 都在公共池中，引用相同
s1 == s3;         // true, s3 与 s1 引用相同
s1 == s4;         // false, 不同引用地址
s4 == s5;         // false, 堆中不同引用地址
 
s1.equals(s3);    // true, 相同内容
s1.equals(s4);    // true, 相同内容
s4.equals(s5);    // true, 相同内容

使用 == 和 equals() 比较字符串。

String 中 == 比较引用地址是否相同，equals() 比较字符串的内容是否相同（注意这里是重写后的equals）

 

 

 

equalsIgnoreCase() 方法

忽略大小写的equals

indexOf() 方法

indexOf() 方法有以下四种形式：
常用
public int indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

public int indexOf(int ch, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

int indexOf(String str, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

lastIndexOf() 方法

lastIndexOf() 方法有以下四种形式：

public int lastIndexOf(int ch): 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

public int lastIndexOf(int ch, int fromIndex): 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索，如果此字符串中没有这样的字符，则返回 -1。

public int lastIndexOf(String str): 返回指定子字符串在此字符串中最右边出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

public int lastIndexOf(String str, int fromIndex): 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索，如果此字符串中没有这样的字符，则返回 -1。

intern() 方法

一般用来判断是否在常量池

length() 方法

length() 方法用于返回字符串的长度。

public class Test {
        public static void main(String args[]) {
                String Str1 = new String("www.runoob.com");
                String Str2 = new String("runoob" );

                System.out.print("字符串 Str1 长度 :");
                System.out.println(Str1.length());
                System.out.print("字符串 Str2 长度 :");
                System.out.println(Str2.length());
        }
}

 matches() 方法

很常见的方法

matches() 方法用于检测字符串是否匹配给定的正则表达式。

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.runoob.com");

        System.out.print("返回值 :" );
        System.out.println(Str.matches("(.*)runoob(.*)"));
        
        System.out.print("返回值 :" );
        System.out.println(Str.matches("(.*)google(.*)"));

        System.out.print("返回值 :" );
        System.out.println(Str.matches("www(.*)"));
    }
}
以上程序执行结果为：

返回值 :true
返回值 :false
返回值 :true

regionMatches() 方法

regionMatches() 方法用于检测两个字符串在一个区域内是否相等。

一般和正则表达式一起出现，regionMatches（）起到一个模糊（区域/精度）判断作用

 

 

 

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("www.runoob.com");
        String Str2 = new String("runoob");
        String Str3 = new String("RUNOOB");

        System.out.print("返回值 :" );
        System.out.println(Str1.regionMatches(4, Str2, 0, 5));

        System.out.print("返回值 :" );
        System.out.println(Str1.regionMatches(4, Str3, 0, 5));

        System.out.print("返回值 :" );
        System.out.println(Str1.regionMatches(true, 4, Str3, 0, 5));
    }
}
}
以上程序执行结果为：

返回值 :true
返回值 :false
返回值 :true

replace() 方法

replace() 方法通过用 newChar 字符替换字符串中出现的所有 searchChar 字符，并返回替换后的新字符串。

public class Main {
    public static void main(String args[]) {
        String Str = new String("Runoob");

        System.out.print("返回值 :" );
        System.out.println(Str.replace('o', 'T'));

        System.out.print("返回值 :" );
        System.out.println(Str.replace('u', 'D'));
    }
}
以上程序执行结果为：

返回值 :RunTTb
返回值 :RDnoob

我们打王者经常看到“李白***你个S13”这个可以做到类似的效果

replaceAll() 方法

上面的replace是字符窜替换，这个是按规则（正则表达式）替换

 1 public class Test {
 2     public static void main(String args[]) {
 3         String Str = new String("www.google.com");
 4         System.out.print("匹配成功返回值 :" );
 5         System.out.println(Str.replaceAll("(.*)google(.*)", "runoob" ));
 6         System.out.print("匹配失败返回值 :" );
 7         System.out.println(Str.replaceAll("(.*)taobao(.*)", "runoob" ));
 8     }
 9 }
10 以上程序执行结果为：
11 
12 匹配成功返回值 :runoob
13 匹配失败返回值 :www.google.com

replaceFirst() 方法

替换一次

 1 public class Test {
 2     public static void main(String args[]) {
 3         String Str = new String("hello China，I am from China。");
 4 
 5         System.out.print("返回值 :" );
 6         System.out.println(Str.replaceFirst("China", "google" ));
 7         System.out.print("返回值 :" );
 8         System.out.println(Str.replaceFirst("(.*)China(.*)", "google" ));
 9     }
10 }
11 以上程序执行结果为：
12 
13 返回值 :hello google，I am from China。
14 返回值 :google

split() 方法

public String[] split(正则表达式分隔符 ,分割的份数可以不写)

split() 方法根据匹配给定的正则表达式来拆分字符串。

注意： . 、 $、 | 和 * 等转义字符，必须得加 \\。

注意：多个分隔符，可以用 | 作为连字符。

public class Test {
    public static void main(String args[]) {
        String str = new String("Welcome-to-Runoob");
 
        System.out.println("- 分隔符返回值 :" );
        for (String retval: str.split("-")){
            System.out.println(retval);
        }
 
        System.out.println("");
        System.out.println("- 分隔符设置分割份数返回值 :" );
        for (String retval: str.split("-", 2)){
            System.out.println(retval);
        }
 
        System.out.println("");
        String str2 = new String("www.runoob.com");
        System.out.println("转义字符返回值 :" );
        for (String retval: str2.split("\\.", 3)){
            System.out.println(retval);
        }
 
        System.out.println("");
        String str3 = new String("acount=? and uu =? or n=?");
        System.out.println("多个分隔符返回值 :" );
        for (String retval: str3.split("and|or")){
            System.out.println(retval);
        }
    }
}
以上程序执行结果为：

- 分隔符返回值 :
Welcome
to
Runoob

- 分隔符设置分割份数返回值 :
Welcome
to-Runoob

转义字符返回值 :
www
runoob
com

多个分隔符返回值 :
acount=? 
 uu =? 
 n=?

substring() 方法

public String substring(int beginIndex)

或

public String substring(int beginIndex, int endIndex)

public class RunoobTest {
    public static void main(String args[]) {
        String Str = new String("This is text");
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4) );
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4, 10) );
    }
}

以上程序执行结果为：

返回值 : is text
返回值 : is te

 

subSequence() 方法

与subString类似只不过这个方法返回一个字符序列（相对subString快一点）

public CharSequence subSequence(int beginIndex, int endIndex)

subSequence() 方法返回一个新的字符序列，它是此序列的一个子序列。

public class Test {
    public static void main(String args[]) {
         String Str = new String("www.runoob.com");

         System.out.print("返回值 :" );
         System.out.println(Str.subSequence(4, 10) );
    }
}
以上程序执行结果为：

返回值 :runoob

toCharArray() 方法

toCharArray() 方法将字符串转换为字符数组。

1 public class Test {
2     public static void main(String args[]) {
3         String Str = new String("www.runoob.com");
4 
5         System.out.print("返回值 :" );
6         System.out.println( Str.toCharArray() );
7     }
8 }

返回值 :www.runoob.com

toLowerCase() 方法

toLowerCase() 方法将字符串转换为小写。

public class Test {
    public static void main(String args[]) {
        String Str = new String("WWW.RUNOOB.COM");

        System.out.print("返回值 :" );
        System.out.println( Str.toLowerCase() );
    }
}
以上程序执行结果为：

返回值 :www.runoob.com

toUpperCase() 方法

toUpperCase() 方法将字符串小写字符转换为大写。

trim() 方法

trim() 方法用于删除字符串的头尾空白符。

 1 public class Test {
 2     public static void main(String args[]) {
 3         String Str = new String("    www.runoob.com    ");
 4         System.out.print("原始值 :" );
 5         System.out.println( Str );
 6 
 7         System.out.print("删除头尾空白 :" );
 8         System.out.println( Str.trim() );
 9     }
10 }
11 以上程序执行结果为：
12 
13 原始值 :    www.runoob.com    
14 删除头尾空白 :www.runoob.com

valueOf() 方法

public class Test {
    public static void main(String args[]) {
        double d = 1100.00;
        boolean b = true;
        long l = 1234567890;
        char[] arr = {'r', 'u', 'n', 'o', 'o', 'b' };

        System.out.println("返回值 : " + String.valueOf(d) );
        System.out.println("返回值 : " + String.valueOf(b) );
        System.out.println("返回值 : " + String.valueOf(l) );
        System.out.println("返回值 : " + String.valueOf(arr) );
    }
}
以上程序执行结果为：

返回值 : 1100.0
返回值 : true
返回值 : 1234567890
返回值 : runoob

contains() 方法

contains() 方法用于判断字符串中是否包含指定的字符或字符串。

public class Main {
    public static void main(String[] args) {
        String myStr = "Runoob";
        System.out.println(myStr.contains("Run"));
        System.out.println(myStr.contains("o"));
        System.out.println(myStr.contains("s"));
    }
}
以上程序执行结果为：

true
true
false

isEmpty() 方法

isEmpty() 方法用于判断字符串是否为空。（原理是通过 length() 方法计算字符串长度，如果返回 0，即为空字符串。）

接参出现问题，用这个方法可以排除空指针问题,所以一些“==”和equals就可以替换这个方法

public class Main {
    public static void main(String[] args) {
        String myStr1 = "Runoob";  
        String myStr2 = "";        // 空字符串
        String myStr3 = "    ";    // 多个空格，length() 不为 0 
        System.out.println("myStr1 是否为空：" + myStr1.isEmpty());
        System.out.println("myStr2 是否为空：" + myStr2.isEmpty());
        System.out.println("myStr3 长度：" + myStr3.length());
        System.out.println("myStr3 是否为空：" + myStr3.isEmpty());
    }
}
以上程序执行结果为：

myStr1 是否为空：false
myStr2 是否为空：true
myStr3 长度：4
myStr3 是否为空：false

 

其他

 

StringBuffer 和 StringBuilder 类

String 类被final修饰不能修改，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象（区别如下）

线程安全：

StringBuffer：线程安全
StringBuilder：线程不安全

速度：

一般情况下，速度从快到慢为 StringBuilder > StringBuffer > String，当然这是相对的，不是绝对的。

使用环境：

操作少量的数据使用 String。
单线程操作大量数据使用 StringBuilder。
多线程操作大量数据使用 StringBuffer。

 1 public class RunoobTest{
 2     public static void main(String args[]){
 3         StringBuilder sb = new StringBuilder(10);
 4         sb.append("Runoob..");
 5         System.out.println(sb);  
 6         sb.append("!");
 7         System.out.println(sb); 
 8         sb.insert(8, "Java");
 9         System.out.println(sb); 
10         sb.delete(5,8);
11         System.out.println(sb);  
12     }
13 }
14 
15 以上实例编译运行结果如下：
16 
17 Runoob..
18 Runoob..!
19 Runoob..Java!
20 RunooJava!

 

 线程不安全是由什么引起的？其实本质就是调用方法实现多线程是不能同步导致的（看以下）

 AbstractStringBuilder的append()方法

1 public AbstractStringBuilder append(String str) {
2     if (str == null)
3         return appendNull();
4     int len = str.length();
5     ensureCapacityInternal(count + len);
6     str.getChars(0, len, value, count);
7     count += len;
8     return this;
9 }

先获取到数据，后才发生改变，如果同时获取到相同数据会发生什么，哈哈

Java 日期时间

这个嘛其实开发中也比较常用，一般都是网上找现成的（不过没网怎么办？比如入职 军工企业）

 

 常用的

import  java.util.*;
import java.text.*;
 
public class DateDemo {
   public static void main(String[] args) {
 
      Date dNow = new Date( );
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
 
      System.out.println("当前时间为: " + ft.format(dNow));
   }
}

Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
int day = c1.get(Calendar.DAY_OF_WEEK);

 

其他

 1 import java.util.Date;
 2  
 3 public class DateDemo {
 4  
 5   public static void main(String[] args) {
 6      // 初始化 Date 对象
 7      Date date = new Date();
 8  
 9      //c的使用  
10     System.out.printf("全部日期和时间信息：%tc%n",date);          
11     //f的使用  
12     System.out.printf("年-月-日格式：%tF%n",date);  
13     //d的使用  
14     System.out.printf("月/日/年格式：%tD%n",date);  
15     //r的使用  
16     System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);  
17     //t的使用  
18     System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);  
19     //R的使用  
20     System.out.printf("HH:MM格式（24时制）：%tR",date);  
21   }
22 }
23 
24 以上实例编译运行结果如下:
25 
26 全部日期和时间信息：星期一 九月 10 10:43:36 CST 2012  
27 年-月-日格式：2012-09-10  
28 月/日/年格式：09/10/12  
29 HH:MM:SS PM格式（12时制）：10:43:36 上午  
30 HH:MM:SS格式（24时制）：10:43:36  
31 HH:MM格式（24时制）：10:43  

 

Scanner 类

 java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入（实现简单交互）。

用法如下

import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
 
        // nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判断是否还有输入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine();
            System.out.println("输入的数据为：" + str2);
        }
        scan.close();
    }
}
执行以上程序输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收：
runoob com
输入的数据为：runoob com

Java 异常处理

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

 

捕获异常

try..catch

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

throw / throws

public void checkNumber(int num) {
  if (num < 0) {
    throw new IllegalArgumentException("Number must be positive");
  }
}

public void readFile(String filePath) throws IOException {
  BufferedReader reader = new BufferedReader(new FileReader(filePath));
  String line = reader.readLine();
  while (line != null) {
    System.out.println(line);
    line = reader.readLine();
  }
  reader.close();
}

finally关键字

finally 关键字用来创建在 try 代码块后面执行的代码块。

无论是否发生异常，finally 代码块中的代码总会被执行。

在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

finally 代码块出现在 catch 代码块最后，语法如下：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

还没完欧，这才刚刚开始

 

 

标签：JAVA,复习,int,System,String,println,public,Restart,out
From： https://www.cnblogs.com/laogao2333/p/17217833.html