Day01 Day02
Java到底有哪些优势？
1.跨平台（平台=OS）可移植性
在不同的操作系统之上可以不用做任何代码的修改
直接使用
a)字节码文件：字节码文件不包括任何内存布
局信息与操作系统和硬件毫无关系(Java的
内存分布是在运行的时候才动态分配的)
b)JVM：真正解释字节码文件内容并且和操作系
统交互的部分Sun(Oracle)已经给每一款操作
系统都写好了现成的JVM
JVM组成部分：
类加载器ClassLoader
字节码校验器
解释执行器（翻译）逐行的解释执行代码
2.安全健壮
3.面向对象
面向过程：
程序：函数+变量（算法+数据结构）
面向对象：
如：SmallTalk
程序：对象和对象相互之间的“通讯”
对象：属性和方法
类：创建对象的模板具有相同特征的一类
事物的高度抽象集合概念
对象是类的实例化，类是对象的抽象
化。
引用
4.动态更新
5.简单！
没有指针和相关的内存操作
new 内存操作
gc 内存回收清理Java中的回收机制：
零引用回收
问题：();
().gc();
调用gc的下一行是否回收？不一定6.免费开源
搭建Java开发平台
(JavaSDK java开发工具包) SDK(软件开发工具包)
JDK安装
JDK 猛虎
JDK 野马
JDK 海豚
JDK JRE JVM
JDK Java开发工具包
JRE Java运行环境
JVM Java虚拟机
JDK = JRE + 常用工具
JRE = JVM + 核心类库
JVM = 三部分
2.设置环境变量
我的电脑-属性-高级-环境变量
为了使开发过程变得更加简单快捷（问题：搭载Java开发平台最少设置几个环境变量？零个。为了方便，不是必要。）
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
分号后面不能加空格
运行过程：
编译期:Java源文件.java编译为字节码文件.class
运行期：JVM --OS硬件
编写代码HelloWorld
如何编译java程序
javac 源文件的名字.java
如何运行java程序
java 类名(没有扩展名)
代码：
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 .
-d 自动创建源文件当中指定的包结构
.在当前目录下创建目录结构
运行语句: java 包名.类名
通过包名和类名来唯一确认一个类
打包语句：package
导包语句：import
例：打包，源文件放在桌面，为了能够运行，定义主
编译：打开CMD，输入“cd 桌面”转到当前目录，编译语句：javac –d .
运行：java （通过包名
+类名唯一确定一个类）例：导包，先写一个打包文件：
编译：javac –d .
编译：javac
运行：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文件
2 编译.java生成.class
javac
3 将class文件打到jar包当中
jar cvf
4 修改jar当中的清单文件，在第三行加入
Main-Class: Test
注意：Test前面有空格
（终止程序的方法：在CMD中输入tskill javaw）
变量
编程语言当中肯定要定义很多很多的变量来存储数据变量分类：
1.定义在类体当中的变量
义在方法体中的变量
局部变量
在自己所在的方法体当中可以使用出方法体消亡
局部变量使用之前一定要初始化
*局部变量和成员变量是可以重名的!在局部变量
数据类型
1.基本数据类型primitive types
8种
boolean
char
byte
short
int
long
float
double
Floating-point numbers without an F suffix (such as 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 method:
double x = ;
int nx = (int) (x);
Now the variable nx has the value 10.
布尔型true / false
字符型
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;
char c1 = '中';
char c2 = 97;
char c3 = '\u0000';
char c4 = '\t';
byte b1 = 1;
byte b2 = 2;
byte b3 = (byte)(b1+b2);1L0.1F
公历闰年的简单计算方法:（符合以下条件之一的年份即为闰年）
1.能被4整除而不能被100整除。（如2004年就是闰年,1900年不是）
2.能被400整除。（如2000年是闰年）
题目:判断年份是不是闰年，有三次输入机会
*/
import
Whenever you use a class that is not defined in the basic package, you need to use an import directive. 注意：Comparable属于
Comparator属于(使用前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++)
{
"×"+i+"="+(i*j)+"\t");
if(j==i)
{
continue outer;
;
public class TestMay162{
public static void main(String[] args){
数组
2.源数组开始复制的下标
3.目标数组
4.目标数组第几个开始放新的值
5.一共放多少个
*/
}
}
public class TestObjectArray
{
public static void main(String[] args)
{
已经知道：有一对熊猫团团圆圆，三个月之后生下一对小熊猫之后每个月生下一对熊猫，小熊猫满三个月之后，每个月生一对儿小熊猫
问：第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<;i++){
iset[i]=iset[i-2]+iset[i-1];
}
}
亮） 现在有一百个人排成一队 第一个人拉所有能把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) "第"+(i+1)+"个房间的灯是亮的"); } } }
class Light{ boolean isOn;
验证哥德巴赫猜想：任何一个大于6的偶数能够拆分成两个质数相加的和 while(number<=6||number%2!=0){
"你输入的数据不合法，请重新输入：");
number=();
}
for(int i=2;i<=number/2;i++){ if(check(i)&&check(number-i)){ "你输入的数字是两个质数"+i+"和"+(number-i)+"的和"); } } } public static boolean check(int num){ for(int i=2;i<=num/2;i++){ if(num%i==0){ return false; } } return true; } }
4. 验证数学黑洞问题：
任意一个4位数，只要不是4位都相同的，那么取它最大排列组合减去最小排列组合，得到的数再取最大排列组合减去最小排列组合，依次类推，不超过7次则肯定会得到数字6174 import .*;
public class TestBlackHole{ public static void main(String[] args){ Scanner sc=new Scanner; "为了验证数学黑洞，请输入一个四位数字，且四位不相同："); String number=(); while(!("6174")){ int max=getMax(number); "的最大排列组合是："+max); int min=getMin(number); "最小排列组合是："+min); number=max-min+""; "二者想减得到的新数字为："+number); } } public static int getMax(String str){ char[] nums=(); (nums); StringBuilder builder=new StringBuilder(new
String(nums));
();
int ok=());
return ok;
}
public static int getMin(String str){
char[] nums=();
(nums);
String s=new String(nums);
int ok=(s);
return ok;
}
}
关于二维数组：Java当中的二维数组其实就是数组（引用类型）的数组，下面一段代码定义了一个存放不同个数元素的数组的数组
int[][] iset = new int[7][];
iset[0] = new int[3];
iset [1] = new int[3];
iset [2] = new int[4];
iset [3] = new int[3];
iset [4] = new int[3];
iset [5] = new int[2];
iset [6] = new int[2];
图示：
Day05
面向对象三大基本特征
封装（encapsulation）
继承（inheritance）
多态（polymorphism）
public class TestEncap{
public static void main(String[] args){
Human hm = new Human();
(30);
}
}
class Human{
private int age;
private String name;
public int getAge(){
return age;
}
public void setAge(int age){
型不同2.个数不同3.顺序不同）
下面这段代码编译时出错，要清楚如何编译、多态、方法重载、方法覆盖！
*/
public class TestOverload{
public static void main(String[] args){
A bb = new B();
(10);
态多态(父类类型子类对象)
2.静态多态编译时多态(Java当中的方法重载Overload )
public class TestSuper{
public static void main(String[] args){
B baby = new B();
();
}
}
class A{
int i = 100;
public void display(){
"A类的display方法");
}
}
class B extends A{
int i = 1000;
public void display(){
打印当前对象的i属性谁调用display谁就是当前对象
打印当前对象的父类对象的i属性();
}
}
图示：
构造器（constructor）
/*
构造器:在构造对象的时候需要调用.构造器没有返回类型名字要和类名完全一样
Java当中每个类都有构造器
构造器通常用来初始化实例变量(属性)
构造器可以重载，但不能被继承，更不能被覆盖！
构造器的第一句肯定是super();或this(); 无参的构造器默认第一句super();
*/
public class TestConstructor{
public static void main(String[] args){
JavaTeacher jt = new JavaTeacher();
}
}
class Teacher{
int age;
String name;
public Teacher(){
"Teacher的无参构造方法被调用了");
}
public Teacher(int age,String name){
"Teacher的有参构造方法被调用了"); 占用的内存如何被释放,而Java当中内存的分配和回收完全是交于GC来自动管理,Java当中的Object类有finalize().但是finalize()和析构函数不是同样的概念,这个方法只是gc回收之前被调用的一个普通方法.
public class TestObject{
public static void main(String[] args){
while(true)
{
Teacher tea = new Teacher(23,"ABC");
性名访问
修饰方法:
这个方法不用通过对象就可以访问，通过类名.方法名()就可以直接调用
但是静态方法当中不能直接访问非静态的属性,不能直接调用非静态的方法
修饰代码块:
静态初始化块(初始化静态属性的)
public class TestStatic1{
public static void main(String[] args){
People peo=new People();
People peo1=new People();
=20;
="Earth";
非静态i是对象的一部分，对象peo对应的i不随peo1的i改变
静态属性home唯一，新对象peo1进行了重新赋值，home的值改变，即People类下所有新new对象home值都改变
不依靠对象存在可以直接通过类名.属性名访问
}
}
class People{
static String home = "地球";
int i=19;
}
运行结果：
19
Earth
Earth
public class TestStatic2{
public static void main(String[] args){
(); 法名() 可以直接调用 性 名访问
Human h1=new Human("you"); ();
}
}
class Human{ static String home="earth"; String name; public Human(String name){ =name; } public static void destroy(){ home="devil"; } public void protect(){ home="heaven"; } }
总结一下对象的创建过程,假设有个名为Dog 的类: 1. 当首次创建类型为Dog 的对象时(构造器可以看成
静态方法),或者Dog 类的静态方法/静态字段首次被访问时,Java 解释器必须查找类路径,以定位文件.
2. 然后载入(创建一个Class 对象),有关静态初始化的
所有动作都会执行.因此,静态初始化只在Class 对象首次加载的时候进行一次.
3. 当用new Dog()创建对象的时候,首先将在堆上为
Dog 对象分配足够的存储空间.
4. 这块存储空间会被清零
,这就自动地将Dog 对象中
的所有基本数据类型都设置成了缺省值,而引用则被设置成了null.
5. 执行所有出现于字段定义处的初始化动作.
6. 执行构造器.
以看到有四种容器:Map、List、Set和Queue。图中常用容器用黑色粗线框表示，点线框表示接口，实线框表示普通类，带有空心箭头的点线表示一个特定的类实现了一个接口，实心箭头表示某个类可以生成箭头所指向类的对象。
下面这个图是集合类库更加完备的图。
ArrayList
import .*;
;
public class TestArrayListEquals{
public static void main(String[] args){
Student stu1 = new Student("张三");
Student stu2 = new Student("李四");
Student stu3 = new Student("李四");
ArrayList al = new ArrayList();
(stu1);
(stu2);
(stu3);
(stu3);
;
public class LotteryTicket{
public static void main(String[] args){
ArrayList box = new ArrayList(23);
;
public class TestLinkedList{
public static void main(String[] args){
LinkedList al = new LinkedList();
(new String("abc"));
(new Teacher());
(1);
for(int i = 0;i<();i++){
}
for(Object obj : al){
}
}
}
class Teacher{
}
;
public class TestSpeed{
public static void main(String[] args){
LinkedList al = new LinkedList();
for(int i = 0;i<=1000000;i++){
(i);
}
long time1 = ();
for(int i = 0;i<=1000000;i++){
Object obj = (i);
}
long time2 = ();
- time1);
}
}
Vector
;
public class TestVector{
public static void main(String[] args){
Vector al = new Vector();
(new String("abc"));
(new Teacher());
(1);
for(int i = 0;i<();i++){
}
for(Object obj : al){
}
}
}
class Teacher{
}
public class TestHashCode{
public static void main(String[] args){
Object obj1 = new Object();
Object obj2 = new Object();
String str1 = new String("abc");
String str2 = new String("abc");
;
public class TestHashSet{
public static void main(String[] args){ HashSet hs = new HashSet();
;
public class Exec{
public static void main(String[] args){
A aa = new A();
A bb = aa;
A cc = bb;
HashSet hs = new HashSet();
(aa);
if(aa == bb){
(bb);
}
if(aa == cc){
(cc);
}
;
public class TestHashSet{
public static void main(String[] args){ HashSet hs = new HashSet();
(new Student(15,"Tom")); ;
public class TestHashSet2nd{
public static void main(String[] args){
HashSet hs = new HashSet();
Teacher tea1 = new Teacher("Robin",30);
Teacher tea2 = new Teacher("Robin",30);
(tea1);
(tea2);
/*
首先第一个元素放进去的时候会调用hashCode()，而不会用equals()进行判断
第二个元素放进来的时候调用这个对象的hashCode()，与集合当中每个已经存在的元素的hashCode()进行比较，（注意，其实只会调用当前要添加元素的hashCode()，已添加元素的hashCode()不会再调用）
1.如果相等:
判断hashCode()相等的那两个对象equals()是否为true
A:equals()也相等只能存一个
B:equals()不相等存入两个
2.如果不等:存入两个
*/
;
public class TestTreeSet{
public static void main(String[] args){
TreeSet ts = new TreeSet();
;
public class Test{
public static void main(String[] args){
public class TestOne{
public static void main(String[] args){
/*
1 按照车牌号降序排列
2 按照座位个数升序排列
*3 随机顺序进行排列
*/
TreeSet ts = new TreeSet(new CarNumberComparator());
(new Car("鲁A12345",24));
(new Car("鲁A88888",30));
(new Car("鲁A11111",23));
for(Object obj:ts){
Car car=(Car)obj;
"\t"+;
}
"==== 华丽的分割线====");
TreeSet ts2 = new TreeSet(new CarSeatComparator());
(new Car("鲁A12345",24));
(new Car("鲁A88888",30));
(new Car("鲁A11111",23));
for(Object obj:ts2){
Car car=(Car)obj; "\t"+;
return false;
/*
做人要负责任做程序员更要负责任
定义一个不是void方法那么必须保证这个方法在任何情况下都得有return 语句
*/
}
}
public class Exec{
public static void main(String[] args){
show(1);
show(1,2);
show(1,2,3,4,6,5,8,7);
}
public static void show(int ... iset){
;
public class TestHashMap{
public static void main(String[] args){
HashMap hm = new HashMap();
;
public class TestHashMap2{
public static void main(String[] args){
HashMap hm = new HashMap();
/*
键是原来的键(先入为主) 而值是后来的值(后来先到)
*/
(new Teacher("马老师"),new Student("张飞"));
(new Teacher("我"),new Student("班长"));
(new Teacher("Robin"),new Student("张飞"));
(new Teacher("马老师"),new Student("班长"));
Teacher("马老师")));
;
public class PhoneBook{
static TreeMap data = new TreeMap();
{
(new NoteInfo("Tom","0531-110") ,new NoteDetail("10000",""));
(new NoteInfo("Jerry","0531-119") ,new NoteDetail("12345",""));
(new NoteInfo("Tom","0531-120") ,new NoteDetail("669688",""));
}
");
return;
}
int count = 1;
ArrayList al = new ArrayList();
"编号\t姓名\t电话");
for(Object obj:keys){
"\t"+obj);
(obj);
count++;
}
String str = getUserInput("请问您想查看哪个联系人的详细信息(放弃请按0)");
int line = (str);
if(line == 0) return;
Object userChoose = (line-1);opy not right..");
}
public static String getUserInput(String tips){
return ();
}
public static void displayMenu(){
"———————");
"｜中国｜");
"｜移动｜");
"｜｜");
"｜ 1.查看｜");
"｜｜");
"｜ 2.添加｜");
"｜｜");
"｜ 3.修改｜");
"｜ ｜"); "｜ 4.删除 ｜"); "｜ ｜
"); "｜ 5.版权 ｜"); "｜ ｜"); "｜ 6.退出 ｜"); "｜ ｜"); "———————"); }
public static void insert(){ "请输入您要添加的联系人的姓名："); String name = ();
"请输入您要添加的联系人的电话：");
String number = ();
"请输入您要添加的联系人的QQ ："); String qq = (); "请输入您要添加的联系人的Email ："); String email = (); NoteInfo key = new NoteInfo(name,number); NoteDetail value = new NoteDetail(qq,email); (key,value); } public static void delete(){ Set keys = (); int count = 1; ArrayList al = new ArrayList(); "编号\t 姓名\t 电话"); for(Object obj:keys){ "\t"+obj); (obj); count++; } String str = getUserInput("请问您想删除第几个用户
(放弃请按0)"); int number = (str); if(number == 0) return; Object key = (number - 1); (key); 对路径 相对于当前文件存放的路径来寻找目标文件 2.绝对路径 从根目录开始定位目标文件 关于路径分隔符 win:\ Unix:/
public class TestCalendar{
public static void main(String[] args)throws Exception{
File doc = new File("");
long time = ();//获得最后一次修改时间
Calendar cal = ();//得到日历对象(time);//指定了日历所代表的时间以long 毫秒数
int year = (1);//
int month = (2)+1;//
int day = (5);//
int hour = (10);
int minute = (12);
int second = (13);
"年"+month+"月"+day+"日"+hour+":"+minute+":"+second);
/*
Date modify = new Date(time);//以time指定的毫秒数来创建日期对象
int year = ()+1900;
int month = ()+1;
int day = ();
int hours = ();
"/"+month+"/"+day);
*/
}
}