part1:001基础知识点
单行注释：//
多行注释：/* */
eclipse中多行注释：选定多行代码+快捷键（ctrl+/）
使用eclipse格式化代码：shift+ctrl+F
输出错误信息与调试信息：System.err.println(),System.out.println()
从控制台接收输入字符：Scanner scanner=new Scanner(System.in);//创建输入流扫描器
检查输入位数：line.length()
强制类型转换：long value=100L;byte btValue=(byte)value;将long型强制转为byte型
加密字符串与解密字符串：..=scan.nextLine()//获取用户输入 ..=passworld.toCharArray();//获取字符数组 遍历数组：用for语句
三元运算符判断奇偶：..条件运算String check=(number%2==0))？：条件结果A：条件结果B
左移运算实现乘法运算:左移n位相当于2的n次方
难点：异或运算的用法b=a^b^a 不借助第三变量实现两个变量互换：借助异或运算符"^"实现两变量高效互换：A=A^B;B=B^A;A=A^B;
求奇数运算"N%2==1"，如果要考虑到负数问题，任何负数应用这个算法的结果都会等于-1
part2:002流程控制语句
if语句
用if...else或者三目运算符(? : )判断闰年。闰年公式：year%4==0&&year%100!=0||yera%400==0
验证登录信息的合法性 （equals()方法判断两字符串内容是否相同，“==”判断的是字符串对象地址）
if(!username.equals("lee"){ //判断用户名合法性
System.out.println("用户名非法");
}else if(!password.equals("123"){判断密码合法性
System.out.println("密码错误");
}else{ //通过以上两个条件判断默认通过登录验证
System.out.println("登陆成功");
}
switch语句
switch(表达式){ //该语句只支持对常量的判断，如java的byte/short/int/char类型
case 常量表达式1:语句序列1
[break;]//可选
...
case 常量表达式n:语句序列n
[break;]//可选
default:语句序列n+1
[break;]//可选
判断用户输入月份的季节
对于多个条件采用相同业务处理的情况，可以把多个case分支关联在一起，省略它们之间的break语句，而在最后一个相同的case分支中实现业务处理并执行break语句
比如下面判断冬季的语句
switch(month){
case 12:
case 1:
case 2:
System.out.println("你输入的月份属于冬季");
break;
while语句
多数情况下，遍历数组都是使用for循环语句实现。其实应用while循环语句和自增运算也可实现。
while(条件表达式){ //条件表达式结果为boolean类型，结果只能是true或false
语句序列 //循环体，在条件表达式为true时执行
}
例子：使用while循环计算1+1/2!+1/3!+...1/20!
for语句
例子
使用for循环输出杨辉三角
使用for循环输入99乘法表
遍历数组
for(初始表达式:条件表达式:循环表达式){
循环体
}
part3:003数组操作
获取一维数组的最小值思路：获取用户输入，用trim()方法去除左右空格，对输入内容进行非法检测，用split()方法将输入的字体串分割成字符串数组，并将字符串数组转换到整型数组，最后在遍历数组的同时提取最小值显示到窗体的标签控件中。
参考：http://leexy.blog.51cto.com/4136883/1303209
将二维数组中的行列互换：通过双层for循环遍历数组
参考：http://leexy.blog.51cto.com/4136883/1304048
利用数组抽取幸运观众：需要用到String类的split()方法和Math的random方法
参考：http://leexy.blog.51cto.com/4136883/1303995
利用数组设置JTable表格的列名和列宽，关键代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
private
JTable getTable(){
if
(table==
null
){
table=
new
JTable();
//创建表格
String[] columns={
"id"
,
"姓名"
,
"性别"
};
//定义列名数组
int
[] columnWidth={
10
,
20
,
30
};
//定义宽数组
//创建表格数据模型
DefaultTableModel model=
new
DefaultTableModel(columns,
15
);
table.setModel(model);
//设置表格数据模型
TableColumnModel columnModel=table.getColumnModel();
//获取列模型
int
count=columnModel.getColumnCount();
//获取列数量
for
(
int
i=
0
;i<count;i++){
//遍历列
TableColumn column=columnModel.getColumn(i);
//获取列对象
column.setPreferredWidth(column Width[i]);
//以数组元素设置列的宽度
}
}
return
table
}
|
使用按钮控件数组实现计算器界面 JButton[][] buttons=new JButton[i][j]
通过复选框控件数组实现添加多个复选框控件 JCheckBox[] boxs=new JCheckBox[labels.length]
数组排序：选择排序法、冒泡排序法、快速排序法、直接插入法、sort()方法
反转数组中元素的顺序
part4:004面向对象
自定义类：创建一个自定义的类，提供构造方法和成员方法给它，最后可以在另一个类的main方法中创建自定义类的对象
举例
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
class
Animal{
//自定义类
private
String dog;
//定义dog
public
Animal(String dog){
//利用构造方法初始化域
this
.dog=dog;
}
public
String getDog(){
//成员方法，获得dog
return
;
}}
再创建一个Test类
public
class
Test{
public
static
void
main(String args[]){
Animal animal=
new
Animal(
"哈皮狗"
);
System.out.println(“我家里养了一只"+animal.getDog());
}
}
|
关于方法调用：温度单位转换例子-在java中使用普通方法需要先创建一个方法所在类的对象，然后通过这个对象调用这个方法。而静态方法可以直接使用类名来调用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public
class
Test{
public
double
getFahrenheit(
double
celsius){
double
fahrenheit=
1.8
*celsius+
32
;
return
fahrenheit;
}
public
static
void
main(String[] args){
System.out.println(
"温度℃"
);
Scanner in=
new
Scanner(System.in);
double
celsius=in.nextDouble();
/*
*静态方法：直接可以用类名调用，不过要确保上面方法是static静态方法
*double fahrenheit=Test.getFahrenheit(celsius);
*/
Test converter=
new
Test();
//创建类的对象
double
fahrenheit=converter.getFahrenheit(celsius);
System.out.println(
"华氏度\n"
+fahrenheit);
}
}
|
成员变量的默认初始化值：对于基本类型的成员变量，虚拟机会自动为其进行初始化，但对于引用变量的变量，在使用之前需要进行初始化，否则会抛出NullPointerException异常。比如
|
1
2
3
4
5
6
7
|
private
byte
b;
//声明基本类型变量b
private
String string;
//声明引用类型变量string
public
static
void
main(String args[]){
Test init=
new
Test();
//创建对象
System.out.println(
"比特类型的初始值："
+init.b);
//结果：比特类型的初始值：0
System.out.println(
"引用类型的初始值"
+init.string);
//结果：引用类型的初始值null
}
|
关于java的基本类型与引用类型，可以参考文章：http://ajava.org/article-9-1.html
单例模式的特点在于仅能获得一个对象。为了防止其他用户创建对象，需要将构造方法设置为private的，然后提供一个一个静态方法，该方法返回这个类的对象。例子可以参考：
http://leexy.blog.51cto.com/4136883/1304452
递归算法完成汉诺塔问题求解：为了将N个盘子从A移动到C，需要先将第N个盘子上面的N-1个盘子移动到B上，这样才能将第N个盘子移动到C上。同理，为了将N-1个盘子从B移动到C上，需要将N-2个盘子移动到A上。比如有6个盘子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
class
Test{
public
static
void
moveDish(
int
level,
char
from,
char
inter,
char
to){
if
(level==
1
){
//如果只有一个盘子就退出迭代
System.out.println(
"从"
+from+
"移动盘子1号到"
+to);
}
else
{
//如果有大于一个盘子就继续迭代
moveDish(level-
1
,from,to,inter);
System.out.println(
"从"
+from+
"移动盘子"
+level+
"号到"
+to);
moveDish(level-
1
,inter,from,to);
}
}
public
static
void
main(String[] args){
int
nDisks=
6
;
//设置汉诺塔为6阶
moveDish(nDisks,
'A'
,
'B'
,
'C'
);
//实现移动算法
}
}
|
利用重载技术编写同名方法(具有相似功能不同参数的方法)：当对象在调用方法时，可以根据方法参数的不同来确定执行哪个方法。方法参数的不同包括参数类型不同，参数个数不同和参数顺序不同。但不能通过返回值来区分方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public
class
Test{
public
void
info(){
//定义无参方法
System.out.println(
"普通方法：小弟弟1岁了"
);
}
public
void
info(
int
age){
//定义包括整型参数的info()方法
System.out.println(
"重载方法：小弟弟"
+age+
"岁了"
);
}
public
static
void
main(String args[]){
Test a=
new
Test();
//测试无参娄info()方法
a.info();
for
(
int
i=
1
;i<
5
;i++){
//测试有参数info()方法
a.info(i);
}
}
}
|
统计图书销售量：在类的构造方法中增加计数器来实现该功能
在Book类中定义一个静态的成员变量用来保存实例化的次数，构造方法实现计数器的功能：
|
1
2
3
4
5
6
7
8
9
10
|
public
class
Book{
private
static
int
counter=
0
;
public
Book(String title){
System.out.println(
"售出图书"
+title);
counter++;
}
public
static
int
getCount(){
return
counter;
}
}
|
在Test类中创建Book类对象并输出创建对象的个数：
|
1
2
3
4
5
6
7
8
9
10
|
public
class
Test {
public
static
void
main(String args[]){
String[] titles={
"A书"
,
"B书"
,
"C书"
};、
//创建书名数组
for
(
int
i=
0
;i<
10
;i++){
new
Book(titles[
new
Random().nextInt(
3
)]);
//new Random().nextInt(3)用于获得
0
-
2
的整数
}
System.out.println(
"总共销售了"
+Book.getCount()+
"本图片"
);
}
}
|
使用字符串输出对象：通过重写toString方法来实现
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
class
Cat{
private
String name;
private
int
age;
private
double
weight;
public
Cat(String name,
int
age,
double
weight){
//初始化
this
.name=name;
this
.age=age;
this
.weight=weight;
}
public
String toString(){
//重写toString方法
StringBuilder sb=
new
StringBuilder();
sb.append(
"名字"
+name+
"\n"
);
sb.append(
"年龄"
+age+
"\n"
);
sb.append(
"重量"
+weight+
"\n"
);
return
sb.toString();
}
}
|
在main()方法中创建Cat类对象
|
1
2
3
4
5
6
7
8
9
10
|
public
class
Test{
public
static
void
main(String args[]){
Cat cat1=
new
Cat(
"JAVA"
,
12
,
21
);
//创建对象并初始化
Cat cat2=
new
Cat(
"WEB"
,
12
,
21
);
Cat cat3=
new
Cat(
"JAVA"
,
12
,
21
);
System.out.println(
"猫咪1号"
+cat1);
System.out.println(
"猫咪2号"
+cat2);
System.out.println(
"猫咪3号"
+cat3);
}
}
|
