Java学习重点笔记精彩版.doc

Day01 Day02
Java究竟有哪些优势？
1.跨平台（平台=OS） 可移植性

在不同操作系统之上可以不用做任何代码修改
直接使用
a) 字节码文献：字节码文献不涉及任何内存布局信息 与操作系统和硬件毫无关系 (Java内存分布是在运营时候才动态分派)
b) JVM：真正解释字节码文献内容并且和操作系统交互某些 Sun(Oracle)已经给每一款操作系统都写好了现成JVM
JVM构成某些：
类加载器 ClassLoader
字节码校验器
解释执行器 （翻译）逐行解释执行代码

2.安全 健壮

3.面向对象

面向过程：
程序：函数+变量 （算法+数据构造）

面向对象：
如：SmallTalk
程序：对象和对象互相之间“通讯”
对象：属性和办法
类： 创立对象模板 具备相似特性一类事物高度抽象集合概念
对象是类实例化，类是对象抽象化。
引用

4.动态更新

5.简朴！

没有指针和有关内存操作
new 内存操作
gc 内存回收清理 Java中回收机制：零引用回收
问题： System.gc();
Runtime.getRuntime().gc();
调用gc下一行与否回收？不一定

6.免费 开源

搭建Java开发平台
1.JDK (JavaSDK java开发工具包) SDK(软件开发工具包)

JDK安装
JDK 1.5 5.0 猛虎
JDK 1.6 6.0 野马
JDK 1.7 7.0 海豚

JDK JRE JVM
JDK Java开发工具包
JRE Java运营环境
JVM Java虚拟机

JDK = JRE + 惯用工具
JRE = JVM + 核心类库
JVM = 三某些

2.设立环境变量
我电脑-属性-高档-环境变量

为了使开发过程变得更加简朴快捷（问题：搭载Java开发平台至少设立几种环境变量？零个。为了以便，不是必要。）

环境变量名字
给谁用
做什么用
PATH
操作系统
更快找到程序
CLASSPATH
JVM(类加载器)
找到字节码文献
JAVA_HOME
其她Java程序
找到JDK

a) PATH 就是为了在任何一种目录下都可以直接访问bin目录下工具(命令)
C:\Program Files\Java\jdk1.6.0_06\bin

b) CLASSPATH 默认值： . (当前目录)

c) JAVA_HOME 设立到JDK安装目录下

JAVA_HOME:JDK安装目录下
CLASSPATH:.
PATH:%JAVA_HOME%\bin
*环境变量名字最佳所有大写
*在CMD设立环境变量时=左右两边不要加空格
*在CMD中定义任意程序环境变量：
如：set PATH=E:\TTPlayer
同步定义两个环境变量中间加分号，或者
Set PATH=%PATH%;E:\TTPlayer
分号背面不能加空格

3.Java运营过程：
编译期:Java源文献.java编译为字节码文献.class
运营期：JVM --OS硬件

编写代码HelloWorld
如何编译java程序
javac 源文献名字.java
如何运营java程序
java 类名(没有扩展名)

HelloWorld.java代码：
public class HelloWorld
{
public static void main(String[] args)
{
System.out.println("Hello!!");
}
}
public 修饰符 modifier
static 修饰符 静态（不用通过对象调用）
void 办法返回值（表达这个办法不需要返回值）
main 标记符

标记符 Identifier
1.必要是英文 _ $ 中文开头
2.不能使用有特殊意义名字（核心字）

类名（接口名）：每个单词首字母大写
属性名和办法名：首字母小写，之后每个单词首字母大写
包名：所有小写

The most common relationships between classes are
• Dependence (“uses–a”)
• Aggregation (“has–a”)
• Inheritance (“is–a”)

类成员：
类可以拥有三种成员：
·字段：它们是类及其对象有关联数据变量，保存着类或者对象状态。
·办法：它们包括类可执行代码并定义了对象行为
·嵌套类（nested class）与嵌套接口（nested interface）：它们是在其她类或接口声明内部声明类与接口。

类修饰符：
·注解（annotation）
·public ：任何人都可以声明对这种类对象引用，或者访问这种类公共成员。
·abstract：抽象类，被以为是不完整，因此咱们不能创立抽象类实例。普通这是由于抽象类包括abstract办法，这些办法必要在子类中实现。
·final：final类不容许拥有子类。类不能既是final又是abstract。
·严格浮点（strict floating point）： 声明为strictfp类规定类中所有浮点运算都是精准运算

Java当中包(相应操作系统当中目录)
1.区别不同命名空间
2.对各种.class文献进行分类归类

编译语句:javac -d . HelloWorld.java
-d 自动创立源文献当中指定包构造
. 在当前目录下创立目录构造
运营语句：java 包名.类名
通过包名和类名来唯一确认一种类
打包语句：package
导包语句：import

例：打包，源文献Student.java放在桌面，为了可以运营，定义主办法main
package iii.ii;
public class Student
{
public static void main(String[] args)
{
System.out.println("Hello!");
}
}
编译：打开CMD，输入“cd 桌面”转到当前目录，编译语句： javac –d . Student.java
运营：java iii.ii.Student
（通过包名+类名唯一拟定一种类）

例：导包，先写一种打包文献：
package iii.ii;
public class Student
{
public static void SayHello()
{
System.out.println("Hello!");
}
}
编译：javac –d . Student.java
然后写导包文献：
import iii.ii.Student;
public class Hello
{
public static void main(String[] args)
{
Student.SayHello();
}
}
编译：javac Hello.java
运营：java Hello

生成协助文档惯用工具 javadoc 语句：
javadoc -d doc 源文献名字.java
Java注释：
单行注释 /
多行注释 /* */
文档注释 /** */
生成jar包
jar包就是java当中可执行压缩归档文献
1.可执行
2.压缩
3.归档 一种java程序也许涉及到诸各种.class 把它们都归纳在一起 变成一种文献
生成jar包语句：
jar cvf 名字.jar 要放进压缩文献里文献
c 创立新归档文献
v 原则输出设备显示详细列表信息
f 指定归档文献名字
生成可执行Jar包详细环节：
1 写.java文献
如，写一种无限弹出计算器代码
public class Test
{
public static void main (String[] args)throws Exception
{
while(true)
Runtime.getRuntime().exec("calc");
}
}

2 编译.java生成.class
javac Test.java
3 将class文献打到jar包当中
jar cvf name.jar Test.class
4 修改jar当中清单文献，在第三行加入
Main-Class：Test
注意：Test前面有空格
（终结程序办法：在CMD中输入tskill javaw）

变量
编程语言当中必定要定义诸多诸多变量来存储数据
变量分类：
1.定义在类体当中变量
成员变量 实例变量
public class HelloWorld
{
int i =100;//成员变量 属性 HelloWorld类型对象均有一份属性
public static void main(String[] args)
{
System.out.println(i);
}
}
构成类对象属性
依托对象来存在 它是对象存储空间当中一某些
实例变量使用前不用初始化

2.定义在办法体中变量
局部变量
在自己所在办法体当中可以使用 出办法体 消灭
局部变量使用之前一定要初始化
*局部变量和成员变量是可以重名!在局部变量所在办法体中直接浮现变量名将代表局部变量
public class TestStudent
{
public static void main(String[] args)
{
Student stu = new Student();
stu.setAge(25);
System.out.println(stu.age);
}
}
class Student
{
int age;
String name;
public void setAge(int age)//
{
//stu.age = 25;
this.age = age;//实例变量和局部变量浮现重名时候，如果不写this.则这句没故意义，打印age默认值0
}
}

数据类型
1.基本数据类型 primitive types
8种
boolean
char
byte
short
int
long
float
double
Floating-point numbers without an F suffix (such as 3.402) are always considered to be of type double.
If you want to round a floating-point number to the nearest integer (which is the more useful operation in most cases)，use the Math.round method:
double x = 9.997;
int nx = (int) Math.round(x);
Now the variable nx has the value 10.

1.boolean 布尔型 true / false
2.char 字符型
3.整数型 （符号位 数值位）
byte 8位 -128 ~ 127
short 16 - 215 ~ 215 -1
int 32 *
long 64 即-2 (n-1) ~ 2(n-1)-1
4.浮点型 （符号位 幂指位 数值位）
float 32位
double 64位 *

2.引用数据类型（自定义类型 对象类型）
无数种
byte short (char) int long float double

自动提高（就近提高）

强制类型转换
这种类型提高规则，对于办法参数匹配同样合用

public class Test
{
public static void main(String[] args)
{
boolean flag = true;
System.out.println(flag);

char c1 = '中';
char c2 = 97;
char c3 = '\u0000';
char c4 = '\t';
byte b1 = 1;
byte b2 = 2;
byte b3 = (byte)(b1+b2);//int类型 强制类型转换

int i1 = 45;
int i2 = 031;//8进制
int i3 = 0x31；//16进制

long l1 = 1;
long l2 = 1L;

float f1 = 0.1F;
double d1 = 0.1D;
}
}

public class TestDataType{
public static void main(String[] args){
int i=10;
get(i);
}
public static void get(byte a){
System.out.println("我是byte型");
}
public static void get(long b){
System.out.println("我是long型");
}
public static void get(double c){
System.out.println("我是double型");
}
}

运营成果：我是long型 （办法参数匹配就近提高）

public class DataType{
public static void main(String[] args){
int i=10;
long d=get(i);
System.out.println(d)； //打印long类型20
}
public static int get(double a){
return (int)a;
}
public static int get(byte b){
return b;
}
public static int get(float c){
return (int)c*2； //自动就近提高，因此调用这个办法，由于返回值为int型，因此代码中要强制类型转换
}
}

short a = 1;
a = a + 1;
编译错误，a+1运算成果是int型，需要强制转换类型
short a = 1；
a += 1;
可以对的编译

public class TestArguments
{
public static void main(String[] args)
{
byte i = 1;
get(i);//办法调用
}

public static void get(short d)//办法定义，办法参数作为局部变量
{
//short d = i;如果再写这句就重复定义
System.out.println(d);
}
}

public class TestArgs
{
public static void main(String[] args)
{
Car benz = new Car();
benz.number = 99999;

changeNumber(benz);

System.out.println(benz.number);
}
public static void changeNumber(Car car)
{
//Car car = benz;//Java当中只有值传递
car.number = 88888;
}
}
class Car
{
int number;
}

画图：

运营成果：
88888

public class TestExec
{
public static void main(String[] args){
IntA ia = new IntA();
ia.i = 55;
change(ia);
System.out.println(ia.i);
}
public static void change(IntA ib)
{
//IntA ib = ia;
ib = new IntA();//如果去掉这句则同上一种例子，运营成果为99
ib.i = 99;
}

}
class IntA
{
int i;
}

画图：

运营成果：
55

public class Exec{
private static int j = 0;
private static boolean methodB(int k)
{
j += k;//j=4;
return true;
}
public static void methodA(int i)
{
//int i = 0;
boolean b;
b = i < 10 | methodB(4);//逻辑非短路
b = i < 10 || methodB(8);//逻辑短路运算符 第二个表达式不必进行判断
}
public static void main(String args[])
{
methodA(0);
System.out.println(j);//4
}
}

public class TestOperator
{
public static void main(String[] args)
{
/*
+ - * / %
*/
System.out.println( -5 % 2 );// % 最后成果取决于被模数符号，打印-1

/*
+= -= *= /= %=
*/
byte b1 = 127;
b1 += 10;//b1 = b1 + 10；=左边是byte 类型 整个表达式依然是byte类型，打印-119
System.out.println(b1);
/*
> < >= <= == !=
*/
int i = 1000;
System.out.println( !(i>=1000))；// 编程语言当中 = 赋值运算符 == 判断与否相等，打印false

/*
逻辑非短路运算符：& | 逻辑短路运算符： && ||
*/
System.out.println( i> && i<5000);//打印false

/*
++ --
*/
int k = 2;
System.out.println(++k);// 如果k++:打印2 ++k:打印3
System.out.println(k);// 打印3
System.out.println(k++ + ++k);//k++ 3 k=4 ++k 5 k=5，打印8

/*
++ -- && || & |
*/
int m = 10;
boolean flag = (m++>=10 || ++m>3);
System.out.println(m);//打印11

/*
instanceof
格式：一种引用 instanceof 一种类
左边引用所指向对象与否是右边类型一种实例
System.out.println(stu instanceof Student);
*/

/*
1 ?2 ：3 三目运算符
*/
int ii = 5;
System.out.println(ii>10 ?100.0 ：1000);//自动提高为三个数值中最大类型，这里打印1000.0

TestOperator.absolute(3);
}
public static void absolute(int number)
{
System.out.println( number>=0 ?number ：-number );
}
}

运算符优先级

转义字符

Day03
流程控制
分支：if else
else与近来if构成一组
switch case
循环：for
while
do while
循环标签：break continue

public class TestSwitchCase
{
public static void main(String[] args)
{
int i = 5;
switch(i)//byte short char int 不能在括号里定义i
{
case 1:System.out.println("i是1");break;

case 2:System.out.println("i是2");break;

case 3:System.out.println("i是3");break;

case 4:System.out.println("i是4");break;

default:System.out.println("i不是1234");break;

}
}
}

public class TestFor
{
public static void main(String[] args)
{
//程序当中相邻相似代码必定可以简化
//打印1到20之间所有偶数

for(int i = 1；i <21；i++)
{
if(i%2==0){
System.out.println(i);
}
}
}
}

public class TestWhile
{
public static void main(String[] args)
{
int i=1;
for(i = 100；i>0 ；i--)
{
System.out.println(i);
}
System.out.println(i);//这句代码已经出for循环，for 循环上面必要定义i
/*
for循环是while循环便捷形式
*/
i = 100;// for 1
while(i>0)//for 2
{
System.out.println(i);//for 4
i--;//for 3
}
}
}

public class TestDoWhile
{
public static void main(String[] args)
{
int i = 9;
do
{
System.out.println("能看到我吗?")；//无论条件与否成立 循环体一方面要执行一次
}
while(++i==10);
}
}

public class TestBreakContinue{
public static void main(String[] args){
for(int i = 10;i>0;i--){

if(i==3) {
//continue;//结束当次循环 直接开始下次循环
break;//结束break所在循环
}
System.out.println(i);
}
System.out.println("循环已经执行结束");
}
}

/*
打印1-100之间所有质数(素数)
*/
public class TestZhiShu
{
public static void main(String[] args)
{
System.out.println(2);
for(int i = 3;i<=100;i+=2)
{
if(checkNumber(i))
{
System.out.println(i);
}
}
}
public static boolean checkNumber(int number)
{
if(number==1)
{
return false;
}
for(int i = 3；i<=(number/2) ；i+=2)
{
if(number%i == 0)
{
return false;
}
}
return true;
}
}

public class ForExec
{
public static void main(String[] args)
{
outer:for(int i = 1;i<6;i++)
{
inner:for(int j = 1;j<6;j++)
{
if(i==3)
{
break outer;
}

System.out.println("i="+i+"\t j="+j);
}
}
}
}

/*
鉴定公历闰年遵循规律为：四年一闰,百年不闰,四百年再闰.
公历闰年简朴计算办法:（符合如下条件之一年份即为闰年）
1.能被4整除而不能被100整除。（如就是闰年,19不是）
2.能被400整除。（如是闰年）

题目:判断年份是不是闰年，有三次输入机会
*/
import java.util.Scanner；//扫描仪
public class TestLeapYear{
public static void main(String[] args){
int i=0;
while(i++<3){
switch(i){
case 1:System.out.println("我是灯神，给你三次机会，请输入你要鉴定年份：");break;
case 2:System.out.println("哈哈，你尚有两次机会，说出你要判断年份：");break;
case 3:System.out.println("你尚有最后机会，输入你要判断年份吧：");
}
Scanner sc=new Scanner(System.in)；//从原则输入设备建立一种扫描仪
int year=sc.nextInt()；//从扫描仪得到一种整数

if((year%100!=0&&year%4==0)||year%400==0){
System.out.println("神灯显灵吧！答案是：This year is a leap year!\n");
}
else{
System.out.println("神灯显灵吧！答案是：This year is not a leap year!\n");
}
}
}
}

使用Scanner需要先导包：
import java.util.*;
Whenever you use a class that is not defined in the basic java.lang package，you need to use an import directive.
注意：Comparable属于java.lang
Comparator属于java.util (使用前import)

public class TestNine
{
public static void main(String[] args)
{
outer:for(int i=1;i<=9;i++)
{
inner:for(int j=1;j<=9;j++)
{ System.out.print(j+"×"+i+"="+(i*j)+"\t");
if(j==i)
{
System.out.println();
continue outer;//或者用break;
}
}
}
}
}

Day04
数组
import java.util.*;
public class TestMay162{
public static void main(String[] args){
//Java当中数组 存储空间等大并且持续
//数组和它存储什么类型数据没有任何关系 数组就是引用类型
int[] a=new int[5]；

//可以通过for循环初始化数组或者遍历数组；数组length属性 标示它当中有几种存储空间
for(int i=0;i<a.length;i++){
a[i]=i;
System.out.println(a[i]);
}

//可以用 foreach循环 遍历数组中每个元素
for(float i:a){
System.out.println(i);
}

//创立匿名数组，可以直接给已有数组重新初始化
a=new int[]{18,11,12,16,14};

//数组排序
Arrays.sort(a)；
for(int i:a){
System.out.println(i);
}

//数组复制
//①手动复制数组
int[] e=new int[a.length]；
for(int i=0;i<a.length;i++){
e[i]=a[i];
}

//②通过Object克隆办法
int[] c=a.clone();

//③通过java.util.Arrays类中copyOf办法
int[] b=Arrays.copyOf(a,a.length)；

//④通过System类当中arraycopy办法
int[] d=new int[a.length]；
System.arraycopy(a,0,d,0,a.length);
/*
arraycopy(1,2,3,4,5)

1.源数组
2.源数组开始复制下标
3.目的数组
4.目的数组第几种开始放新值
5.一共放多少个
*/
}
}

public class TestObjectArray
{
public static void main(String[] args)
{
//引用类型数组 初始化数组并不等于初始化当中元素
//数组被初始化了 数组当中元素（学生对象）还没被初始化
Student[] et0903 = new Student[5];

for(int i = 0;i<et0903.length；i++)
{
et0903[i] = new Student();
}
//for循环 数组当中元素 学生对象 已经完毕了初始化工作
}
}
class Student
{
int age;
String name;
public void study()
{
System.out.println(name+"好好学习，每天向上");
}
}
上例图示：

运用数组解决四个问题:
1. 已经懂得：有一对熊猫 团团圆圆 ，三个月之后生下一对小熊猫之后每月生下一对熊猫，小熊猫满三个月之后，每月生一对儿小熊猫
问：第23个月 熊猫总共多少只？
分析：每月小熊猫对数关系为1 1 2 3 5 8 13 21 ...
public class Panda{
public static void main(String[] args){
int[] iset=new int[23];
iset[0]=1;
iset[1]=1;
for(int i=2;i<iset.length;i++){
iset[i]=iset[i-2]+iset[i-1];
}
System.out.println(iset[22]);
}
}
2. 已经懂得：100个房间，每个房间里有一盏灯（不亮） 当前有一百个人排成一队
第一种人拉所有能把1整除房间里灯
第二个人拉所有能把2整除房间里灯
。。。。。。。。。。
第100个人拉所有能把100整除房间里灯
问：最后哪些灯是亮（考虑实现效率！）
public class TestLight{
public static void main(String[] args){
Light[] room=new Light[100];
for(int i=0;i<100;i++){
room[i]=new Light();
}
for(int human=1;human<=100;human++){
for(int number=1;number<=100;number++){
if(number%human==0)
room[number-1].pull();
}
}
for(int i=0;i<100;i++){
if(room[i].isOn)
System.out.println("第"+(i+1)+"个房间灯是亮");
}
}
}
class Light{
boolean isOn；//boolean型默认值是false
public void pull(){
isOn=!isOn;
}
}

3. 验证哥德巴赫猜想