【Java】初识Java
文章目录
-
-
-
- Java的工作方式
- Java中的数据类型
-
- 主数据类型
-
- 手动包装、拆包
- 自动包装、拆包
- 包装类的静态方法
- 数字的格式化
- 日期的格式化
- 对象引用
- 释放对象引用的三种方式
- 数据比较
- Java中的内存
-
- 堆(heap)
- 栈(stack)
- 面向对象编程
-
- 猜数字游戏
- Java API：ArrayList
- 修复版猜数字游戏
- 构造函数
- Java API：Math
- Java API：Date
- Java API：Calendar
-
-
Java的工作方式
源代码经过编译器编译后会生成一个字节码文件，字节码文件是一种二进制的类文件，它的内容是JVM的指令，而不是像C、C++经由编译器直接生成机器码，因此字节码文件不能被系统直接执行，而是需要虚拟机解释执行。
Java中的数据类型
每个应用程序只有一个main()函数，Java虚拟机启动执行时调用main()，main()是应用程序的起点。
.jar文件，manifest指定了哪个文件中有main()方法。
public class HelloWorld {
public static void main(String[] args){
int x = 3;
double d = Math.random();
String name = "Nicholas";
System.out.println("x:"+x);
System.out.println("d:"+d);
System.out.println("name:"+name);
System.out.println("--------------------");
String[] words = {"hello","world"};
System.out.println("words.length:"+words.length);
System.out.println("words[0]:"+words[0]);
System.out.println("words[1]:"+words[1]);
System.out.println("--------------------");
double a = 12.3;
int b = (int) a;
System.out.println("a:"+a);
System.out.println("b:"+b);
double i = 56.7;
int j = (int) i;
System.out.println("i:"+i);
System.out.println("j:"+j);
}
}
Java是强类型语言，必须声明所有变量的类型。
主数据类型
| 数据类型 | 说明 | 对应的包装类 |
|---|---|---|
boolean |
true 或false |
Boolean |
char |
16位（0 ~ 216-1，即 0 ~ 65535） | Character |
byte |
8位（ -27 ~ 27-1，即-128 ~ 127） | Byte |
short |
16位（-215 ~ 215-1，即-32768 ~ 32767） | Short |
int |
32位（-231 ~ 231-1） | Integer |
long |
64位(-很大 ~ +很大) | Long |
float |
32位 | Float |
double |
64位 | Double |
手动包装、拆包
public class Test {
public static void main(String[] args){
int x = 28;
Integer wrapper = new Integer(x);
int unWrapper = wrapper.intValue();
}
}
自动包装、拆包
import java.util.ArrayList;
public class Test {
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
System.out.println(list.get(0));
System.out.println(list.get(1));
}
}
包装类的静态方法
- String转换成主数据类型
Integer.parseInt()Double.parseDouble()new Boolean("false").booleanValue()
- 主数据类型转换成String
Integer.toString()Double.toString()
public class Test {
public static void main(String[] args){
String s = "42";
int i = Integer.parseInt(s);
String s2 = Integer.toString(i);
String str = "3.14";
double d = Double.parseDouble(str);
String str2 = Double.toString(d);
String string = "true";
boolean b = new Boolean(string).booleanValue();
}
}
数字的格式化
-
String.format(格式,数值)
第一个参数是格式化串，第二个参数是需要被格式化的数值。String.format("%,d",100000000)
使用%,d这种格式将数值100000000格式化。
其中，%代表需要被格式化的数值，,d意思是用逗号分隔这个数值，所以
String.format("%,d",100000000)的结果是100,000,000。String.format("I have %.2f bugs to fix",1234.5678)
使用%.2f将数值1234.5678格式化。
其中，%代表需要被格式化的数值，.2f意思是小数点后保留两位，所以
String.format("I have %.2f bugs to fix",1234.5678)的结果是I have 1234.57 bugs to fix。String.format("I have %,.2f bugs to fix",1234.5678)
使用%,.2f将数值1234.5678格式化。
其中，%代表需要被格式化的数值，,.2f意思是整数部分用逗号分隔，小数点后保留两位，所以
String.format("I have %,.2f bugs to fix",1234.5678)的结果是I have 1,234.57 bugs to fix。
| 格式化指令 | 说明 |
|---|---|
%d |
被格式化的值的类型必须与int兼容 |
%f |
被格式化的值的类型必须是float/double中任一种 |
%x |
被格式化的值的类型必须是byte/short/int/long/BigInteger中任一种 |
%c |
被格式化的值的类型必须是byte/short/int/long中任一种 |
public class Test {
public static void main(String[] args){
System.out.println(String.format("%,.1f",42.000));
System.out.println(String.format("0042.0"));
System.out.println(String.format("%,6.1f",42.000));
}
}
public class Test {
public static void main(String[] args){
int i = 20456654;
double j = 100567890.248907;
System.out.println(String.format("The rank of %,d out of %,.2f",i,j));
}
}
日期的格式化
| 格式化指令 | 说明 |
|---|---|
%tc |
完整的日期和时间 |
%tr |
时间 |
%tA |
周 |
%tB |
月 |
%td |
日 |
import java.util.Date;
public class Test {
public static void main(String[] args){
Date d = new Date();
System.out.println(d);
System.out.println(String.format("%tc",d));
System.out.println(String.format("%tr",d));
System.out.println(String.format("%tA",d));
System.out.println(String.format("%tB",d));
System.out.println(String.format("%td",d));
System.out.println(String.format("%tA,%tB,%td",d,d,d));
System.out.println(String.format("%tA,%,d));
}
}
对象引用
对象，有自己的实例变量和方法。
创建的对象会保存在堆中。当某个对象被Java虚拟机察觉到不再被使用，该对象会被标识为可回收。内存不足时垃圾收集器会启动以清理垃圾、回收空间。
引用变量，可以理解成 指向对象的指针。
对于任何一台Java虚拟机而言，所有引用变量的大小都是一样的，不论它实际引用的对象大小如何。
数组也是一个对象。
public class Helloworld {
public static void main(String[] args){
int[] nums = new int[3];
nums[0] = 10;
nums[1] = 20;
nums[2] = 30;
for(int i=0;i<nums.length;i++){
System.out.println(nums[i]);
}
}
}
释放对象引用的三种方式
- 对象引用是一个局部变量
在方法中声明对象引用，即让对象引用成为一个局部变量，这样，方法一旦执行完毕，对象引用也会被释放
public class Dog{
public void bark(){
Hippo hippo = new Hippo();
System.out.println("dog didn't know hippo");
}
}
public class Hippo{
}
public class Test {
public static void main(String[] args){
Dog dog = new Dog();
dog.bark();
}
}
bark()方法一调用完，局部变量hippo就会被销毁。
- 引用被赋值了其他对象
public class Dog{
public void bark(){
Hippo hippo = new Hippo();
hippo = new Hippo();
System.out.println("dog didn't know hippo");
}
}
第一个创建的Hippo对象会在hippo被重新赋值时销毁。
- 将对象引用置为
null
public class Dog{
public void bark(){
Hippo hippo = new Hippo();
hippo = null;
System.out.println("dog didn't know hippo");
}
}
hippo被置为null时，第一个创建的Hippo对象会被销毁。
数据比较
==可以用来比较两个主数据类型的值是否相等、两个对象引用是否引用的是堆上的同一个对象。
Java中的内存
堆(heap)
所有的对象都在堆上。
对象有自己的实例变量和方法，所以，实例变量存在于对象所属的堆上。
如果实例变量是主数据类型，Java会根据主数据类型的大小在堆上为该实例变量分配空间。比如，int需要32位，long需要64位。
如果实例变量是另一个的对象引用，就要分两种情况，
第一种，只是声明了引用变量，但并没有赋值，那么只会在堆上为该引用变量分配空间；
第二种，引用变量被赋值了一个对象，则还需要在堆上为该对象分配空间。
栈(stack)
方法调用和局部变量保存在栈上。
当一个方法被调用，该方法会被放在调用栈的栈顶。
面向对象编程
将实例变量标记为private，将Setters和Getters标记为public。
public class DogTestDrive {
public static void main(String[] args){
Dog one = new Dog();
one.setSize(80);
System.out.println(one.getSize());
one.bark();
Dog two = new Dog();
two.setSize(30);
System.out.println(two.getSize());
two.bark();
Dog three = new Dog();
three.setSize(8);
System.out.println(three.getSize());
three.bark();
}
}
public class Dog {
private int size;
public void setSize(int s){
size = s;
}
public int getSize(){
return size;
}
public void bark(){
if(size>60){
System.out.println("Wooof!Wooof!");
}else if(size>14){
System.out.println("Ruff!Ruff!");
}else{
System.out.println("Yip!Yip!");
}
}
}
public class Dog {
private int size;
private String name;
public int getSize(){
return size;
}
public String getName(){
return name;
}
public void bark(){
}
}
public class DogTestDrive {
public static void main(String[] args){
Dog d = new Dog();
System.out.println(d.getSize());
System.out.println(d.getName());
}
}
实例变量的初始化非必要，因为它们有自己的默认值。
| 数据类型 | 默认值 |
|---|---|
boolean |
false |
char |
0 |
byte |
0 |
short |
0 |
int |
0 |
long |
0 |
float |
0.0 |
double |
0.0 |
| 对象引用 | null |
猜数字游戏
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class GameHelper {
public String getUserInput(String prompt){
String inputLine = null;
System.out.print(prompt+": ");
try{
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
inputLine = reader.readLine();
}catch(IOException e){
System.out.println("IOException： " + e);
}
return inputLine;
}
}
public class Game {
private int[] locationCells;
private int numOfHits = 0;
public void setLocationCells(int[] locs){
locationCells = locs;
}
public String check(String stringGuess){
String result = "miss";
int guess = Integer.parseInt(stringGuess);
for(int cell:locationCells){
if(guess == cell){
result = "hit";
numOfHits++;
break;
}
}
if(numOfHits == locationCells.length){
result = "kill";
}
System.out.println(result);
return result;
}
}
public class GameTestDrive {
public static void main(String[] args){
int numOfGuesses = 0;
Game game = new Game();
int randomNum = (int) (Math.random()*5);
int[] locationCells = {randomNum,randomNum+1,randomNum+2};
game.setLocationCells(locationCells);
GameHelper helper = new GameHelper();
boolean isActive = true;
while(isActive){
String guess = helper.getUserInput("enter a number");
numOfGuesses++;
if(game.check(guess) == "kill"){
isActive = false;
System.out.println("You took " + numOfGuesses +" guesses");
}
}
}
}
一个很明显的bug是，连续输入2，也能结束游戏。
Integer.parseInt()
将代表数字的String转换成int- 强制类型转换
int randomNum = (int) (Math.random()*5) - for循环
for(int cell:locationCells){}
Java API：ArrayList
ArrayListisEmpty()size()contains()indexOf()get()add()remove()
import java.util.ArrayList;
public class Test {
public static void main(String[] args){
ArrayList<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
System.out.println(list.isEmpty()); // false
System.out.println(list.size()); // 2
System.out.println(list.contains("Hello")); // true
System.out.println(list.contains("World")); // true
System.out.println(list.indexOf("Hello")); // 0
System.out.println(list.indexOf("World")); // 1
System.out.println(list.get(0)); // Hello
System.out.println(list.get(1)); // World
list.remove(0);
System.out.println(list.contains("Hello")); // false
list.remove("World");
System.out.println(list.contains("World")); // false
System.out.println(list.isEmpty()); // true
System.out.println(list.size()); // 0
}
}
修复版猜数字游戏
前面我们提到了一个bug，连续输入2，也能结束游戏。
现在来修复这个bug，解决方法是，localtionCells不用数组，用ArrayList。
import java.util.ArrayList;
public class Game {
private ArrayList<String> locationCells = new ArrayList<String>();
private int numOfHits = 0;
public void setLocationCells(ArrayList<String> locs){
locationCells = locs;
}
public String check(String stringGuess){
String result = "miss";
int index = locationCells.indexOf(stringGuess);
if(index >= 0){
locationCells.remove(index);
if(locationCells.isEmpty()){
result = "kill";
}else{
result = "hit";
}
}
System.out.println(result);
return result;
}
}
import java.util.ArrayList;
public class GameTestDrive {
public static void main(String[] args){
int numOfGuesses = 0;
Game game = new Game();
int randomNum = (int) (Math.random()*5);
ArrayList<String> locs = new ArrayList<String>();
locs.add(String.valueOf(randomNum));
locs.add(String.valueOf(randomNum+1));
locs.add(String.valueOf(randomNum+2));
game.setLocationCells(locs);
GameHelper helper = new GameHelper();
boolean isActive = true;
while(isActive){
String guess = helper.getUserInput("enter a number");
numOfGuesses++;
if(game.check(guess) == "kill"){
isActive = false;
System.out.println("You took " + numOfGuesses +" guesses");
}
}
}
}
java.util.ArrayList
Java函数库中每个类都属于某个包。
类ArrayList的完整名称是java.util.ArrayList，所以import java.util.ArrayList。
类String的全称是java.lang.String；
类System的全称是java.lang.System；
类Math的全称是java.lang.Math，
但使用它们三个时，我们并没有import java.lang.String、import java.lang.System、import java.lang.Math，
因为java.lang是经常用到的基础包，所以Java会预先将java.lang这个包引用进来。
构造函数
构造函数与类同名，且没有返回值。
构造函数用来初始化对象。
最好有一个无参的构造函数。
public class Animal {
public Animal(){
System.out.println("Making an Animal");
}
}
public class Hippo extends Animal {
public Hippo(){
System.out.println("Making a Hippo");
}
}
public class Test {
public static void main(String[] args){
Hippo hippo = new Hippo();
}
}
Java API：Math
Math.random()
返回0.0~1.0之间的双精度浮点数。Math.abs()
返回双精度浮点数类型参数的绝对值。Math.round()
根据参数是浮点型或双精度浮点数返回四舍五入之后的整型或长整型值。Math.max()
返回两个参数中的较大值。Math.min()
返回两个参数中的较小值。
Java API：Date
new Date()getTime()
import java.util.Date;
public class Test {
public static void main(String[] args){
Date date = new Date();
System.out.println(date);
System.out.println(date.getTime());
}
}
Java API：Calendar
Calendar.getInstance()
import java.util.Calendar;
import java.util.GregorianCalendar;
public class Test {
public static void main(String[] args){
System.out.println(new GregorianCalendar() instanceof Calendar);
}
}
import java.util.Calendar;
import java.util.GregorianCalendar;
public class Test {
public static void main(String[] args){
Calendar calendar = Calendar.getInstance();
System.out.println(calendar instanceof GregorianCalendar);
}
}
set(int year,int month,int date,int hourOfDay,int minute)
将时间设定为某年某月某日某时某分。
import java.util.Calendar;
public class Test {
public static void main(String[] args){
Calendar calendar = Calendar.getInstance();
calendar.set(2020,10,16,21,25);
System.out.println(calendar.getTime());
}
}
getTimeInMillis()
将时间转换成毫秒值。
import java.util.Calendar;
public class Test {
public static void main(String[] args){
Calendar calendar = Calendar.getInstance();
calendar.set(2020,10,16,21,25);
System.out.println(calendar.getTime());
System.out.println(calendar.getTimeInMillis());
}
}
setTimeInMills(long millis)
用毫秒值来设定时间
import java.util.Calendar;
public class Test {
public static void main(String[] args){
Calendar calendar = Calendar.getInstance();
calendar.set(2020,10,16,21,25);
System.out.println(calendar.getTime());
System.out.println(calendar.get(calendar.HOUR_OF_DAY));
System.out.println(calendar.get(Calendar.HOUR));
long newDay = calendar.getTimeInMillis()+3600*1000;
calendar.setTimeInMillis(newDay);
System.out.println(calendar.get(calendar.HOUR_OF_DAY));
System.out.println(calendar.get(calendar.HOUR));
}
}
get(int field)
取出指定字段的值calendar.YEAR
年calendar.MONTH
月，从0开始，0就代表1月calendar.DATE
日calendar.HOUR_OF_DATE
时，24小时制calendar.MINUTE
分calendar.SECOND
秒calendar.MILLISECOND
import java.util.Calendar;
public class Test {
public static void main(String[] args){
Calendar calendar = Calendar.getInstance();
calendar.set(2020,10,16,21,25);
System.out.println(calendar.getTime());
System.out.print(calendar.YEAR);
System.out.print(" ");
System.out.println(calendar.get(calendar.YEAR));
System.out.print(calendar.MONTH);
System.out.print(" ");
System.out.println(calendar.get(calendar.MONTH));
System.out.print(calendar.DATE);
System.out.print(" ");
System.out.println(calendar.get(calendar.DATE));
System.out.print(calendar.HOUR_OF_DAY);
System.out.print(" ");
System.out.println(calendar.get(calendar.HOUR_OF_DAY));
System.out.print(calendar.MINUTE);
System.out.print(" ");
System.out.println(calendar.get(calendar.MINUTE));
System.out.print(calendar.SECOND);
System.out.print(" ");
System.out.println(calendar.get(calendar.SECOND));
System.out.print(calendar.MILLISECOND);
System.out.print(" ");
System.out.println(calendar.get(calendar.MILLISECOND));
System.out.println(calendar.getTimeInMillis());
}
}
add(int field,int amount)
import java.util.Calendar;
public class Test {
public static void main(String[] args){
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());
calendar.add(calendar.DATE,3);
System.out.println(calendar.getTime());
}
}
import java.util.Calendar;
public class Test {
public static void main(String[] args){
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());
calendar.add(calendar.DATE,14);
System.out.println(calendar.getTime());
}
}
roll(int filed,int amount)
和add(int field,int amount)的区别是，roll(int filed,int amount)不进位。
import java.util.Calendar;
public class Test {
public static void main(String[] args){
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());
calendar.roll(calendar.DATE,14);
System.out.println(calendar.getTime());
}
}
getTimeZone()
获取时区信息
import java.util.Calendar;
public class Test {
public static void main(String[] args){
Calendar calendar = Calendar.getInstance();
calendar.set(2020,10,16,21,25);
System.out.println(calendar.getTime());
System.out.println(calendar.getTimeZone().getDisplayName());
System.out.println(calendar.getTimeZone().getID());
System.out.println(calendar.getTimeZone().getRawOffset()/(3600*1000));
}
}
