JAVA学习笔记1
来源：互联网 发布：gps数据处理软件 编辑：程序博客网 时间：2024/04/29 08:28
Module 1: Getting Started 第1章 入门
Module 2: dentifiers, Keywords and Types 第2章 标识符、关键字以及数据类型
Module 3: Expressions and Flow Control 第3章 表达式和流程控制
Module 4: Array 第4章 数组
Module 5: Objects and Classes 第5章 对象和类
Module 6: Advanced Language Features 第6章 高级特性
Module 7: Exceptions 第7章 异常
Module 8: Building GUIs 第8章 创建GUI界面
Module 9: The AWT Component Library 第9章 AWT组件库
Module 10: The AWT Event Model 第10章 AWT事件模型
Module 11: JFC 第11章 JFC框架
Module 12: Applets 第12章应用小程序
Module 13:Thread 第13章线程
Module 14: Stream I/O and Files 第14章输入输出流和文件系统
Module 15: Networking 第15章网络
1.类的组成：5部分
*包（package）几个具有相同功能的类放在一个包；没写（默认的包）；只能放在第一行，最多只能写一行（一个类只放在一个包）；规范：包名必须全部是小写字母
*导入（import）system在java.lang中，常使用，可以不用import导入
使用了其它包的类，需要引入，本类要使用另一个类，并且这2个类不在同一包中
*表示包中所的有类；在同一包中不需要引入；可以写多行，放在Class类声明之前
*类的声明（public class）
一个源文件中只能包含一个public类，但是可以存多个类，文件名必须是public类.java
类名首字母必须大写；类名在有意义的基础上要简略；一般使用英文单词，但是可以使用中文
多个单词时，每个单词的首字母都要大写
*{类体}中的属性，变量【封装类的属性-->项目有哪些需求，特征】
*{类体}中的方法
main（）方法，入口方法；参数名可以改，其它格式固定；要运行，测试必须写main()
构造方法：方法名与类名相同，没有返回类型，也不是void类型
业务方法：set(),get()方法
方法名首字母要小写，多个字母时，从第二个字母开始首字母要大写
方法组成：修饰符+返回类型+方法名+参数列表+抛异常+方法体 主要考虑（返回类型和参数列表）
2.Java环境的搭配：
从官网下载JDK（JavaSE）（分为windows环境下和Linux环境下）
安装JDK（jdk-6u12-windows-i586-p.exe）
配置环境变量：JAVA_HOME，CLASSPATH，PATH
JAVA_HOME= C:\Program Files\Java\jdk1.6.0_12 //bin文件夹之前 java的根目录
PATH=% JAVA_HOME %\bin; //path+原有路径
CLASSPATH=.; //类路径，运行java路径 .代表当前路径
3.java程序的编译和运行：
编译：javac –d . FirstJava.java
运行：java smple. FirstJava
4.3种注释符
//单行注释符（快捷键Shift+/）
/* */多行注释符(快捷键Shift+Alt+/)
/** */文档注释
注意：只有文档注释 将来使用javadoc命令可以产生文档，并在文档中作为注释信息
5.标识符：类、方法和变量名称
以字母，_，$开头，由字母，数字，_，$组成
区分大小写
没有长度限制
Example: Student2，getName()， $99，ab12
6.java中的原始类型：8种
boolean true or false 不能用数字
byte 8-bit integer 1个字节 8位 -128—127
char 16-bit unicode character 2个字节 16位
double 64-bit floating-point number 8个字节 64位
float 32-bit floating-point number 4个字节 32位
int 32-bit integer 4个字节 32位
long 64-bit integer 8个字节 64位
short 16-bit integer 2个字节 16位
记忆：4个整数型（byte、short、int、long），2个小数型，1个布尔型，1个字符型
7.String字符串：
是类，不是原始类型
不能被继承，是final类
不用\0结尾 在默认情况下字符串包含一个unicode字符序列 创建对象的方式有2种：
（1直接赋值 String name="张三";
(2)使用构造方法创建 String name=new String("张三");
考题：String name=new String("zhangsan")创建了几个对象？
2个对象
String字符串一旦创建，是定长的字符转，是不可以改变的
String n="zhangsan";
n=n+"1234";这样性能低，通常使用StringBuffer或StringBuilder类
8.48个关键字
abstract do implements private throw boolean double import protected throws break else instanceof public transient byte extends int return true case
false interface short try catch final long
static void char finally native super volatile
class float new switch while continue for
null synchronized default if package this
其中instanceof是判断类型匹配的
transient 是临时状态的
native 是本地的
volatile 是隔离的
synchronized 是线程同步
9.java中的基础包：
java.lang
java.awt/
javax.swing/
java.awt.event
java.applet
Java.io //流
Java.net //网络
Java.util //
10.语句用“;”结束 程序块用{}包含代码 多个空格是没有意义的
11.整数有三种表示方法：8进制（零开头），10进制，16进制（零X开头）
在java中出现的整数默认是int型
java中的浮点数缺省是double
long float是32位长的浮点数 long double是64位长的浮点数
float数字以F或者f结尾 double数字以D或d结尾
考题： short s3=1;
s3=s3+1;错误 要统一类型改成S3=（short）(s3+1);正确
s3+=1; 正确 相当于直接赋值
12.推荐的标识符命名规则
类名以大写字母开头classAccount {…}
接口以大写字母开头interfaceAccountBase {…}
方法以小写字母或单词开头StringgetStudentName() {…}
变量以小写字母或单词开头StringstudentName;
常量以大写字母表示 final public static intMAX_ROW= 100;
13.编写一个老师Teacher类
属性 name、sex、salary
方法 set get方法 main方法
《1》测试：创建两个老师，打印每个老师的信息
《2》增加方法：增加工资方法 addSalary方法，实现工资增加500功能，测试
《3》增加方法：增加工资方法 addSalary2方法，实现工资可以任意增加功能，测试
public class Teacher{
private String name;
private String sex;
private double salary;
public Teacher(){} //无参数构造方法
public Teacher(String name,String sex,double salary){ //带参数构造方法
this.name=name;
this.sex=sex;
this.salary=salary;
}
public void setName(String name){
name=name;
}
public String getName(){
return name;
}
public void setSex(String sex){
sex=sex;
}
public String getSex(){
return sex;
}
public void setSalary(double salary){
salary=salary;
}
public double getSalary(){
return salary;
public String toString(){ //重写toString()方法
return name+" "+sex+" "+salary;
}
public void addSalary(){ //增加工资方法 addSalary方法，实现工资增加500功能
salary+=500;
}
public void addSalary2(double salary2){ //增加工资方法 addSalary2，工资可以任意增加
salary=salary+salary2;
}
public static void main(String []args){
Teacher t=new Teacher("张三","男",73364.2464);
System.out.println(t);
t.addSalary();
System.out.println(t);
t.addSalary2(526354.2136);
System.out.println(t);
}
}
14.学习使用API文档，查看String，练习String类的一些方法的使用完成如下作业：
String str = "abc3dfg";
判断str中是否有1-9数字
如果有将字符串逆序输出
如果没有原序输出
public class StringTest{
public static void main(String []args){
System.out.println("请输入字符串"); //键盘输入字符串
Scanner reader=new Scanner(System.in);
String str=reader.next();
char[] cs=str.toCharArray(); //字符数组
int i;
for(i=0;i<cs.length;i++){
if(cs[i]>='1'&&cs[i]<='9'){
for(int j=cs.length-1;j>=0;j--){
System.out.print(cs[j]);
}
break;
}
}
if(i>=cs.length){
System.out.println(cs);
}
}
}
2011.7.19 周二
1.Java中小数默认是double
float f=3.14 错误改成 float f=3.14f或是float f=3.14F对
原始类型范围：[-2n-1,2n-1-1]
2.变量的声明：
intx,y,z; //只声明
float z=3.144f; //声明并赋初值
public class Assign{
private int i; //成员变量 实例变量
private String student_name;
private final doublePI=3.14; //常量
public void setStudent_name(String n){
student_name = n;
}
public static void main(String [] args){
int i; //局部变量 内存不会自动初始化
//i =10; //在使用局部变量前必须初始化
System.out.println(i); //只声明变量i未初始化
Assign assign = new Assign();
System.out.println(assign.i); //输出0
}
}
3.类与对象：
类：描述群体的共性
（1)变量或属性或：名词
(2)方法或功能：set（）和get（） 动词
万物皆对象 在大多数情况下是名词 具有属性或者成员
有对自身属性或成员操作的方法 使用new关键字创建实例
4.原始类型和引用类型的区别:
原始类型变量的赋值
int x = 10; int y = x;
引用类型变量的赋值
Teacher teacher = new Teacher(“John Smith”, 30, 10000);
或Teacher teacher, teacher_Clone;
teacher = new Teacher(“John Smith”, 30, 10000);
teacher_Clone = teacher;
实例：public class PrimitiveRefType{
public static void main(String [] args){
//原始类型 将x值10赋值给y之后x和y没有关系
int x =10;
int y = x;
x =100;
System.out.println("x="+x); //输出x=100
System.out.println("y="+y); //输出y=10
//引用类型
Teacher t1;//声明变量
t1 = new Teacher("z3",30,5000.0);
System.out.println("t1第一次:"+t1.getName()); //t1第一次:z3
Teacher t2 = t1; //将t1引用地址赋值给t2
t2.setName("L4");
System.out.println("t1===="+t1.getName()); //t1====L4
System.out.println("t2===="+t2.getName()); //t2====L4
}
}
5.局部变量及作用范围：
自动变量，临时变量，栈变量 在方法中或者在类{}中的{}定义的
使用前必须初始化
6.实例变量及作用范围：
在类的{}定义的
自动初始化，并有初始值
byte short int long float double char boolean All reference types
0 0 0 0L 0.0f 0.0d ‘\u0000’ false null
实例：public class LocalVariable{
private int i; //成员变量或实例变量
private boolean bl; //boolean默认false
private String name; //所有类类型 默认值null
private Teacher t; //默认值null
//private int a = 8;
public void a(){
int a = 9; //局部变量出了包含的{}就不可用
}
public void b(){
//int b = a; //错误的 a出了a()方法就不可用
}
public static void main(String[]args){
int c ; / /局部变量
c = 0; //局部变量使用前必须初始化
int d = c; //编译报错 可能尚未初始化变量 c
System.out.println(c);
//成员变量,如果没有初始化，程序会采用各种类型的默认值初始化
LocalVariable lv = new LocalVariable();
System.out.println(lv.i);
System.out.println(lv.bl);
System.out.println(lv.name);
System.out.println(lv.t);
}
}
7.Operators（操作符）
赋值运算符:=、*=、+=、-=、/=、%=、>>=、<<=、>>>=、&=、^=、|=
比较运算符：<、<=、>、>=、instanceof
相等运算符：==、！=
算术运算符：+、 -、 * 、 /、 %
移位运算符：>>、 <<、 >>> （没有<<<） (二进制运算)
位比较运算符:&、 ^、 |、 ~ （&都为1得到1，|有一个1得到1） (二进制运算）
逻辑运算符：&&、||、！ (&&与||称为短路运算)
条件运算符：？、：
实例：public class OperatorTest{
public static void main(String []args){
int i = 4;
int b = i<<2; //左移扩大 2n次方 4*2的n次方
int c = i>>3; //右移 缩小 2n次方 4/2的n次方
System.out.println(b);
System.out.println(c);
int j1 = 3;
int j2 = 4;
int j3 = j1&j2;
int j4 = j1|j2;
System.out.println(j3);
System.out.println(j4);
String str = "aaaaa";
if(str!=null&&str.length()>3){
System.out.println("字符串长度大于3");
}
String str2 = null;//str2不一定是什么值
if("abc".equals(str2)){
System.out.println("字符串为abc");
}
?：
(条件表达式)?值1:值2
可以嵌套的
int m1 = 10;
int m2 = 20;
int m3 =(m1>m2)?m1:m2; //返回较大值
System.out.println(m3);
int sc = 70;
}
}==用在原始类型中，类类型不用==
短路运算：String str=null;
if(str!=null&&str.length()>3) 因为str!=null为False,所以str.length()>3不执行
String str2=null;
if("abc".equal(str2))或if(str2!=null&&str2.equal("abc"))
8.类型转换两大类
《1》隐式类型转换 小---》大
原始类型（大小指范围）
int---->long
float--->double
int--->double
引用类型（大小指父子关系）
String-->Object
Student-->Object
《2》强制类型转换 大---》小（损失精度）
原始类型（大小指范围）
long---->int
double--->float
double--->int
引用类型（大小指父子关系）
Object-->String
Object-->Student
语法 （强制转换的类型）变量
例如： long l = 100L;
int i = (int)l;
注意：当我们将变量1强制转换为某类型时，一定注意是否能够转换过去
实例：public class Casting{
public static void main(String[]args){
int i = 10;
long l = i; //隐式转换
float f = 2.0f;
double d = f;
String str = "abc";
Object o1 = str; //o1类型是Object o1对象是String
int j = (int)l; //强制类型转换
float f2 = (float)d;
float f3 = (float)2.0;
String str2 = (String)o1;
System.out.println(str2);
//注意
Object o2 = new Object();
//强制类型转换异常java.lang.ClassCastException
//String str3 =(String) o2; //出错
}
}
9.if....else
<1>. if (布尔表达式){
代码语句块
}
<2>. if(布尔表达式){
代码语句块
} else {
代码语句块
}
<3>. if(布尔表达式){
代码语句块
} else if(布尔表达式){
代码语句块
}
else {
代码语句块
}
注意：if中{}可以省略，但是代码块出现多行时必须加上{}，因为If只控制后面一行
10.switch(变量a){
case 1:
case 2:
...
...
default:
}
Switch(a)中的变量a必须是byte,short,char,int中的一种
每个case语句中需要加上break;语句
而default语句可以放在开始，中间或者末尾位置实例：
public class SwitchTest{
public static void main(String[]args){
int month;
switch(month){
case 1:
System.out.println("1月"+31);
break; //break跳出switch循环
case 2:
System.out.println("2月"+29);
break;
case 3:
System.out.println("3月"+31);
break;
case 4:
System.out.println("4月"+30);
break;
case 5:
System.out.println("5月"+31);
break;
case 6:
System.out.println("6月"+30);
break;
default:
System.out.println("default"+30);
}
}
}
11.for(循环变量;循环表达式;循环变量的变化 ){
}
for括弧中必须为3部分，每部分可以不写代码，但两个;必须有
for(;;){} //死循环
实例：int sum =0;
for(int i=1;i<=100;i++){
sum = sum+i; //求1加到100的和
}
System.out.println(sum);
增强型for each循环
for(String s:args)—>(变量：数组或集合){
System.out.println(s);
}
12.（1）While:
实例：int sum2 = 0;
int j =1;
while(j<=100){
sum2 = sum2+j; //求1加到100的和
j++;
}
System.out.println(sum2);
（2）Do...while:
实例：int sum3 =0;
j=1;
do{
sum3 = sum3+j; //求1加到100的和
j++;
}while(j<=100);
System.out.println(sum2);
区别：Do...while至少执行一次语句，While可能一次也不执行；当条件一开始为真时一样
13.//for求10！
public class ForTest{
public static void main(String []args){
int sum=1;
for(int i=1;i<=10;i++){
sum=sum*i;
}
System.out.println(sum);
}
}
14.//while求10！
public class WhileTest{
public static void main(String []args){
int sum=1;
int i=1;
while(i<=10){
sum=sum*i;
i++;
}
System.out.println(sum);
}
15.//do while求10！
public class DoWhileTest{
public static void main(String []args){
int sum=1;
int i=1;
do{
sum=sum*i;
i++;
}while(i<=10);
System.out.println(sum);
}
}
16.使用递归求10！
public class DiGui{
public static void main(String []args){
System.out.println(fun(10));
}
public static int fun(int n){
if(n==1)
return 1;
else
return n * fun(n-1);
}
}
17.有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
* 假如兔子都不死，问每个月的兔子总对数为多少？
* 程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....（递归）
public class TuZi{
public static void main(String []args){
int t1=1,t2=1,t3=0;
for(int i=1;i<=20;i++){
if(i==1||i==2){
System.out.println("第"+i+"个月的兔子总数为："+t1);
}
else{
t3=t1+t2;
System.out.println("第"+i+"个月的兔子总数为："+t3);
t1=t2;
t2=t3;
}
}
}
}
18.利用条件运算符的嵌套来完成此题：学习成绩> =90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
* 程序分析：(a> b)?a:b这是条件运算符的基本例子。
public class OperatorTest{
public static void main(String []args){
int score =97;
String result = score>=90?"A":((score>=60&&score<90)?"B":"C");
System.out.println(result);
}
}
//(条件表达式)?值1:值2
19.打印出所有的 "水仙花数 "，所谓 "水仙花数 "是指一个三位数，其各位数字立方和等于该数本身。
* 例如：153是一个 "水仙花数 "，因为153=1的三次方＋5的三次方＋3的三次方。
* 程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
public class ShuiXianHua{
public static void main(String[] args){
int n=0,x,y;
for (int i=1; i<=9; i++) {
for (int j=0; j<=9; j++) {
for (int k=0; k<=9; k++) {
x=i*i*i+j*j*j+k*k*k;
y=i*100+j*10+k;
if (x==y) {
n++;
System.out.print(y+" ");
}
}
}
}
}
}
20.判断101-200之间有多少个素数，并输出所有素数。
* 程序分析：判断素数的方法：用一个数分别去除2...直到这个数，如果能被整除，则表明此数不是素数，反之是素数。
public class SuShu{
public static void main(String []args){
System.out.println("101到200间的素数有： ");
for(int i=101;i<=200;i++){
boolean flag=true;
for(int j=2;j<=Math.sqrt(i);j++){
if(i%j==0){
flag=false;
break;
}
}
if(flag==true){
System.out.print(i+" ");
}
continue;
}
}
}
21.编写程序，实现字母的加密，首先输出原始字母password!，然后将这个一系列原始字母加密，每个字母都变成字母表中其后的5个字符输出。
public class PassWord{
public static void main(String [] args){
String str="password";
System.out.println("原字符串：" + str);
char [] c=str.toCharArray();
for(int i=0;i<=c.length-1;i++){
c[i]=(char)(c[i]+5);
System.out.print(c[i]);
}
}
}
2011.7.20 周三 （数组）
1.Eclipse的使用
先新建一个 java project工程，然后在src下新建一个包sample,最后在sample下新建一个类Book。
快捷键 Alt + /
多行注释：选中内容 + Ctrl + Shift + /或是：Ctrl + /
撤销注释：选中内容 + Ctrl + Shift + \或是：按2次Ctrl + /
添加构造方法，set&get方法，toString()（在Source下）
2.使用递归求阶乘
package test;
public class DiGui {
public long jieCheng(int n){
if(n<0){
return -1;
}else if(n<=1){
return 1;
}else{
return n* jieCheng(n-1);
/**
* n=10
* 10!= 10*9!
* 9*8!
* 8*7!
* ...
*
* ...
* 2*1!
* 1
*/
}
}
public static void main(String[] args) {
DiGui dg = new DiGui();
long result = dg.jieCheng(10); //成员方法要New对象调用方法
System.out.println(result);
}
}
3.数组：一个有固定大小，可以容纳相同类型数据的集合
一个数组就是一个对象；声明数组并没有创建数组
声明数组语法：int[] iArray; //原始类型 //常用
int iArray2 []; //也可以
Teacher[] tArray; //引用类型，Teacher为一个类
创建数组用New关键字，New类型[长度]，创建数组时必须指明长度；
创建好数组后，数组中元素并没有被初始化
创建数组语法：iArray = new int[3];
tArray = new Teacher[3];
数组中元素的位置由索引index决定；index从0---长度-1；
* 当我们使用索引index超出范围 就会报异常
*越界异常 运行时异常 java.lang.ArrayIndexOutOfBoundsException
初始化数组语法：iArray[0]=1;
iArray[1]=2;
iArray[2]=3;
Teacher t1 = new Teacher();
t1.setName("zhangsan");
tArray[0] = t1;
tArray[1] = new Teacher();
tArray[2] = new Teacher();
System.out.println(tArray[0].getName());
数组的声明创建初始化一步完成
double[] dArray = new double[]{2.2,3.0,4.8};
Teacher [] tArray={t1,new Teacher(),new Teacher()}
打印输出数组：
for(int i=0;i<iArray.length;i++){ //打印输出数组
System.out.println(iArray[i]);
}
for(inti=1;i<=dArray.length;i++){ //打印输出数组
System.out.println(dArray[i-1]);
}
for(inti=0;i<=lArray.length-1;i++){ //打印输出数组
System.out.println(lArray[i]);
}
数组的长度：iArray.length 字符串有String.length()
增强型：for(int i:iArray){ //从头循环到尾
i为取出的元素
多维数组：int [][] iArray;
iArray=new int[4][] 或 iArray=new int[4][3] 但是不能 iArray=new int[][3]
创建多维数组必须指明第一维长度，第二维可以不指定
int [][]iArray={{11,12,13},{5,4,7,6,8}} 取6 iArray[1][3]
多维数组的长度：iArray.length 为第一维的长度
iArray[1].length 为第二维的长度
打印输出用两层For循环：int [][] iArray1={{1,2,3,4},{7,5,4}};
for(int i=0;i<iArray1.length;i++){ //打印输出数组
for(int j=0;j<iArray1[i].length;j++){
System.out.println(iArray1[i][j]);
}
}
4.break与continue的区别：
break:终止当前的循环语句跳出，立刻结束包含它的循环
continue:终止当前循环，进入下一个循环，立刻结束当前循环，进入下次循环
public static void main(String[] args) {
for(int i=1;i<=10;i++){
if(i%2==0){
break; //break执行就立刻结束包含它的循环
}
System.out.println(i); // 输出1
if(i%2==0){
continue; //continue执行就立刻结束当前循环，进入下次循环
}
System.out.println(i); //输出1，3,5,7,9
}
}
5.给定一个多维数组，找最大最小值：
public class Max_Min {
public static void main(String[] args) {
int[][] mXnArray = { {16, 7, 12},{9, 20, 18}, {14, 11, 5}, {8, 5, 10} };
int max=mXnArray[0][0];
int min=mXnArray[0][0];
for(int i=0;i<mXnArray.length;i++){
for(int j=0;j<mXnArray[i].length;j++){
if (mXnArray[i][j]>max){
max=mXnArray[i][j];
}
if (mXnArray[i][j]<min){
min=mXnArray[i][j];
}
}
}
System.out.println("最大值为"+max);
System.out.println("最小值为"+min);
}
}
定义一个String[][] 求最小和最大的字符串
public class StringTest {
public static void main(String[] args) {
String[][]s={{"gy","ffd","g12","e44","2f","3w","4dg"},
{"hwr","hv","uwee","ed","tj","tg","2kk","1hk","4gh"}, {"ghk","ehgj","t2","35t","233y","21y"},
{"134","554","f5","jv","sde","dtyt","12"}};
String max=s[0][0];
String min=s[0][0];
for(int i=0;i<s.length;i++){
for(int j=0;j<s[i].length;j++){
if(s[i][j].compareTo(max)>0){
max=s[i][j];
}
if(s[i][j].compareTo(min)<0){
min=s[i][j];
}
}
}
System.out.println("最大字符串为："+max);
System.out.println("最字小符串为："+min);
}
}
6.冒泡排序
public static void main(String[] args) {
int [] b={10,4,9,3,4,23,164};
for(int i=0;i<b.length;i++){
for(int j=0;j<b.length-i-1;j++){ //j不能到最后一个，所以必须length-i-1
if(b[j]>b[j+1]){
int temp =b[j];
b[j]=b[j+1]; //交换
b[j+1]=temp;
}
}
}
for(int maopao:b)
System.out.println(maopao);
}
7.有一组具有名称、价格、作者的书籍资料，可以按照书籍的价格升序进行排序，并打印出结果；按书名排序输出
public class Book { //先创建Book类
private String title;
private String author;
private int price;
public Book() {}
public Book(String title, String author, int price) {
this.title = title;
this.author = author;
this.price = price;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String toString(){
return title+" "+author+" "+price;
}
}
public class BookSort { //创建书的对象类
public static void main(String[] args) {
Book b1=new Book("Java","耿祥义",23);
Book b2=new Book("C++","郑旭丽",135);
Book b3=new Book("C","韩非",76);
Book b4=new Book("asp","李四",734);
//按价格排序输出
Book [] a={b1,b2,b3,b4}; //Book类型数组
for(int i=0;i<a.length;i++){
for(int j=0;j<a.length-i-1;j++){
if(a[j].getPrice()>a[j+1].getPrice()){ //调用get和setPrice方法
Book temp=a[j]; //交换顺序
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
for(Book jiage:a)
System.out.println(jiage);
System.out.println(" ");
//按书名排序输出
Book [] c={b1,b2,b3,b4};
for(int i=0;i<c.length;i++){
for(int j=0;j<c.length-i-1;j++){
if(c[j].getAuthor().compareTo(c[j+1].getAuthor())>0){ //用compareTo比较字符串大小
Book temp=c[j];
c[j]=c[j+1];
c[j+1]=temp;
}
}
}
for(Book shuming:c) //增强型循环输出
System.out.println(shuming);
}
}
8.编写程序将华氏温度78度转换为摄氏温度，转换成的摄氏温度在屏幕上显示出来：
转换公式为：摄氏度=(5/9)*(华氏度-32)
public class TemperatureConverse {
//华氏温度转换为摄氏温度
public double hToc(double h){
return (5.0/9)*(h-32);
}
public static void main(String[] args) {
TemperatureConverse tc=new TemperatureConverse(); //必须先创建对象
double h1=78;
System.out.println("78℉= "+tc.hToc(h1)+" ℃"); 通过对象调用方法
System.out.println();
}
}
9：异常：
空值异常
类型转换异常
数组越界异常
10.Eclipse快捷键：
运行作用域 功能 快捷键
全局 单步返回 F7
全局 单步跳过 F6
全局 单步跳入 F5
全局 单步跳入选择 Ctrl+F5
全局 调试上次启动 F11
全局 继续 F8
全局 使用过滤器单步执行 Shift+F5
全局 添加/去除断点 Ctrl+Shift+B
全局 显示 Ctrl+D
全局 运行上次启动 Ctrl+F11
全局 运行至行 Ctrl+R
全局 执行 Ctrl+U
重构作用域 功能 快捷键
全局 撤销重构 Alt+Shift+Z
全局 抽取方法 Alt+Shift+M
全局 抽取局部变量 Alt+Shift+L
全局 内联 Alt+Shift+I
全局 移动 Alt+Shift+V
全局 重命名 Alt+Shift+R
全局 重做 Alt+Shift+Y
源代码作用域 功能 快捷键
Java编辑器 格式化 Ctrl+Shift+F
Java编辑器 取消注释 Ctrl+
Java编辑器 注释 Ctrl+/
Java编辑器 添加导入 Ctrl+Shift+M
Java编辑器 组织导入 Ctrl+Shift+O
Java编辑器 使用try/catch块来包围 Ctrl+1
项目作用域 功能 快捷键
全局 全部构建 Ctrl+B
文件作用域 功能 快捷键
全局 保存 Ctrl+X Ctrl+S
全局 打印 Ctrl+P
全局 关闭 Ctrl+F4
全局 全部保存 Ctrl+Shift+S
全局 全部关闭 Ctrl+Shift+F4
全局 属性 Alt+Enter
全局 新建 Ctrl+N
文本编辑
作用域 功能 快捷键
文本编辑器 改写切换 Insert
文本编辑器 上滚行 Ctrl+↑
文本编辑器 下滚行 Ctrl+↓
搜索
作用域 功能 快捷键
全局 出现在文件中 Ctrl+Shift+U
全局 打开搜索对话框 Ctrl+H
全局 工作区中的声明 Ctrl+G
全局 工作区中的引用 Ctrl+Shift+G
导航作用域 功能 快捷键
Java编辑器 打开结构 Ctrl+F3
全局 打开类型 Ctrl+Shift+T
全局 打开类型层次结构 F4
全局 打开声明 F3
全局 打开外部javadoc Shift+F2
全局 打开资源 Ctrl+Shift+R
全局 后退历史记录 Alt+←
全局 前进历史记录 Alt+→
全局 上一个 Ctrl+,
全局 下一个 Ctrl+.
Java编辑器 显示大纲 Ctrl+O
全局 在层次结构中打开类型 Ctrl+Shift+H
全局 转至匹配的括号 Ctrl+Shift+P
全局 转至上一个编辑位置 Ctrl+Q
Java编辑器 转至上一个成员 Ctrl+Shift+↑
Java编辑器 转至下一个成员 Ctrl+Shift+↓
文本编辑器 转至行 Ctrl+L
窗口作用域 功能 快捷键
全局 激活编辑器 F12
全局 切换编辑器 Ctrl+Shift+W
全局 上一个编辑器 Ctrl+Shift+F6
全局 上一个视图 Ctrl+Shift+F7
全局 上一个透视图 Ctrl+Shift+F8
全局 下一个编辑器 Ctrl+F6
全局 下一个视图 Ctrl+F7
全局 下一个透视图 Ctrl+F8
文本编辑器 显示标尺上下文菜单 Ctrl+W
全局 显示视图菜单 Ctrl+F10
全局 显示系统菜单 Alt+-
查看作用域 功能 快捷键
全局 放大 Ctrl+=
全局 缩小 Ctrl+-
编辑作用域 功能 快捷键
全局 查找并替换 Ctrl+F
文本编辑器 查找上一个 Ctrl+Shift+K
文本编辑器 查找下一个 Ctrl+K
全局 撤销 Ctrl+Z
全局 复制 Ctrl+C
全局 恢复上一个选择 Alt+Shift+↓
全局 剪切 Ctrl+X
全局 快速修正 Ctrl1+1
全局 内容辅助 Alt+/
全局 全部选中 Ctrl+A
全局 删除 Delete
全局 上下文信息 Alt+？
Java编辑器 显示工具提示描述 F2
Java编辑器 选择封装元素 Alt+Shift+↑
Java编辑器 选择上一个元素 Alt+Shift+←
Java编辑器 选择下一个元素 Alt+Shift+→
文本编辑器 增量查找 Ctrl+J
文本编辑器 增量逆向查找 Ctrl+Shift+J
全局 粘贴 Ctrl+V
全局 重做 Ctrl+Y
F3: 察看声明打开声明
ctrl + shift + g：查看引用
ctrl + shift + n：重命名
ctrl + shift + o：导入类
ctrl + shift + r：启动上次运行
ctrl + shift + f：格式化代码
ctrl + shift + t：查找相关信息
ctrl + c：复制
ctrl + v：粘贴
ctrl + x：切剪
ctrl + a：全选
ctrl + f：查找
ctrl + z：撤销
ctrl + y：重做
ctrl + s：保存
Ctrl + M: 工作区最大化/最小化
Crtl+1: 修正错误
Shift+Alt+T: 重构
Shift+Alt+M: 提取函数
Shift+Alt+R: 重命名
Shift+Alt+C: 更改函数标记
Ctrl+Shitf+F: 格式化代
Alt + / 智能提示
Alt + shift + r 重命名变量
2011.7.21 周四
1. / 的两边可以是整数 整数/整数=整数
/ 的两边也可以是double类型 9.0/5或 9/5.0都为double型数据
2.数组的拷贝：
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 参数：
src -源数组。
srcPos -源数组中的起始位置。
dest -目标数组。
destPos -目标数据中的起始位置。
length -要复制的数组元素的数量。
public static void main(String[] args) {
int [] iArray =new int[]{1,2,3,4,5};
int [] destArray ={10,9,8,7,6,5,4,3,2,1};
System.arraycopy(iArray, 0, destArray, 0, iArray.length);
for(int i:destArray){
System.out.print(i+"\t");
}
//数组工具类 Arrays 实现比如查找、排序（Sort)、
返回指定数组内容的字符串表示形式(toString)
}
3.导入java工程：import->General->Existing Projects into Workspace->找到工程->选中Copy Projects into Workspace即可
4.查找之前必须先对数据进行排序（升序或是降序）---二分查找法
5.i++:先使用i的原值，然后将i加1
++i：先使i加1，再使用i加后的值
执行1，2行代码后，x,a,b三个变量的值是什么？c
1. Int x, a=6, b=7;
2. X = a++ + b++; //x = 13, a = 7, b=8
如果换成 X = ++a + ++b //x = 15, a = 7, b=8;
6. int x = 4;
System.out.println(“value is “ + ((x>4)?99.9:9)); //类型自动转换为Double型
//运行结果为：value is 9.0
7.类与对象：
封装：Encapsulation
继承：Inheritance
多态：Polymorphism------->父类型子对象
Java中类声明的和实现同时进行。
方法的语法：一般只需考虑返回类型和参数列表
<modifiers><return_type><name>([<argument_list>]) [throws <exception>] {<block>}
修饰符 返回类型 方法名 参数列表 抛异常 方法体
如果方法内没有返回值时，返回类型定义为Void
构造方法没有返回值，也没有Void
8.假设已经创建了A类
则 A a=new A() System.out.println(a+b); 是错误的
A b=new A() System.out.println(a+" "+b); 是正确的
9.参数传递：
原始类型参数传递 值传递
引用类型参数传递 传递引用 实质也是值传 注意：引用类型传递只能改变对象的内容，而不能改变完整的对象
public class ParamPassTest {
* 原始类型参数传递值传递
public void a(int i){
i++;
System.out.println("a()===="+i);
}
* 引用类型传递引用 实质也是值传递
public void changePersonName(Person p){
p.setName("zhangsan");
System.out.println(p.getName());
}
* 引用类型传递只能改变对象的内容，而不能改变完整的对象
public void changePerson(Person p){
p = new Person();//改变对象本身
p.setName("zhangsan");
System.out.println(p.getName());
}
public static void main(String[] args) {
ParamPassTest ppt = new ParamPassTest();
int i = 9;
System.out.println(i);//9
ppt.a(i);//a()====10
System.out.println(i);//9
Person p = new Person();
p.setName("aaa");
System.out.println(p.getName());//aaa
ppt.changePersonName(p);//zhangsan
System.out.println(p.getName());//zhangsan
Person p2 = new Person();
p2.setName("bbb");
System.out.println(p2.getName());//bbb
ppt.changePerson(p2);
System.out.println(p2.getName());//bbb
}
}
10.This关键字：
this两种主要的用法
《1》this.参数与成员变量相同时，用This区分
this 代表当前类实例
this.属性 或 this.方法
《2》this(XXX,xxx) 同一个类中，构造方法之间互相调用
this()必须出现在构造方法中的第一行功能代码
public class ThisTest {
public ThisTest(){
//int i = 1; //如果有该行代码 this()就报错
this(10);//调用另一个整型参数的构造方法 必须放第一行
int i = 1;//可以这样
}
public ThisTest(int age){
this.age = age;
}
private int age;
public void setAge(int age){
this.age = age;
}
public void a(int a){
this.setAge(a);
}
public static void main(String[] args) {
ThisTest tt = new ThisTest();
//tt.setAge(10);
//this.setAge(10);
}
}
11.封装
习惯要求
* 一般会将属性private私有化，提供统一的public方法来完成属性的操作
* 私有化的属性只能在当前类中对象.属性可以使用，
* 其他类不能访问私有变量
* 增强了可维护性
12.方法的重载（Method Overloading）
要求：《1》几个方法在同一个类中
《2》方法名相同,参数列表一定不相同（参数个数、类型、顺序）
注意：参数列表是否相同 不能由参数名决定
参数名只是形参
《3》返回类型可以不同
13.编写Person类，包括姓名、年龄及熟悉setter getter方法，根据年龄查找Person方法（注意：该方法要求下面测试类中初始化数据年龄不能相同）
测试类PersonTest类
使用数组初始化10个数据（年龄不能相同）
完成调用根据年龄查询Person的方法，如果有打印该对象的姓名年龄信息，如果没有打印没有此人。
public class Person {
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+" "+age;
}
}
public class PersonTest {
public void findPersonByAge(int a,Person[]p){
boolean flag=false;
for(int i=0;i<p.length;i++){
if(p[i].getAge()==a){
System.out.println(p[i]);
flag=true;
}
}
if(flag==false){
System.out.println("没有此人");
}
}
public static void main(String[] args) {
Person p1=new Person("zhangsan",12);
Person p2=new Person("lisi",7);
Person p3=new Person("wamhwu",98);
Person p4=new Person("hangshu",76);
Person p5=new Person("gaodeng",53);
Person p6=new Person("shenyu",32);
Person p7=new Person("yangxin",26);
Person p8=new Person("liuli",32);
Person p9=new Person("xiongxiuxin",29);
Person p10=new Person("shixi",31);
Person []p={p1,p2,p3,p4,p5,p6,p7,p8,p9,p10};
PersonTest pt=new PersonTest();
pt.findPersonByAge(32, p);
}
}
14.编写函数double fun(double h)，它的功能是：四舍五入并保留两位小数。
public class SheRu {
public double fun(double h){
long sheRu=Math.round(h*100);
return sheRu/100.0;
}
public static void main(String[] args) {
SheRu sh=new SheRu ();
System.out.println(sh.fun(1664776.67578));
}
}
15.青年歌手参加歌曲大奖赛，有10个评委对她的进行打分，试编程求这位选手的平均得分（去掉一个最高分和一个最低分）。
double a[]={7,9,8,7.5,8.6,9.2,9.7,9.4,8.5,8};
public class Average {
public static void main(String[] args) {
double a[]={7,9,8,7.5,8.6,9.2,9.7,9.4,8.5,8};
double sum=0;
double average=0;
double max=a[0];
double min=a[0];
for(int i=0;i<a.length;i++){
if(a[i]>max){
max=a[i];
}
if(a[i]<min){
min=a[i];
}
}
for(int i=0;i<a.length;i++){
sum+=a[i];
}
average=(sum-max-min)/8;
//System.out.println(sum);
//System.out.println(max);
//Sysem.out.println(min);
System.out.println(average);
}
}
16.编程将字符串 \_0\_4d_a3转换为 \UL___0_\UL___ddddd_d___a_3
public class StringConverse {
public static void main(String[] args) {
System.out.println("请输入字符串");
Scanner reader=new Scanner(System.in);
String str=reader.next();
char[] cs=str.toCharArray();
String result=" ";
for(int i=0;i<cs.length-1;i++){
if(cs[i]=='\\'){
result +="\\UL_";
}
else if(cs[i]=='_'){
result +="_";
}
else if((cs[i]<='9'&& cs[i]>'0')&&(cs[i+1]<='z'&&cs[i+1]>'a')){
int k=cs[i]-48;
for(int j=0;j<=k;j++){
result+= cs[i+1];
}
}
else
result+=(cs[i]+"_");
}
result+= cs[cs.length-1];
System.out.print(result);
}
}
2011.7.22 周五
1、四舍五入并保留两位小数
double fun(double h)
{ return int(h*100+0.5)/100.0; }
或是 public double fun(double h){
long sheRu=Math.round(h*100);
return sheRu/100.0;
}
2.创建和初始化对象：new对象时，先对成员变量初始化，再执行构造函数
创建无参数构造方法时：先进入无参构造函数，然后给成员变量赋值，然后跳出无参构造函数，最后结束
创建带参数构造方法时：先进入带参构造函数，然后给成员变量赋值，然后再把参数替换成传入的参数，最后结束
3. * 构造方法
* 《1》方法名和类名相同
* 《2》没有任何返回类型 也没有void
* 《3》当没有定义构造方法时，java在编译时会
* 自动提供一个不带有参数的缺省的构造方法。
* 注意：如果自己手写了任何构造方法，
* 系统不再提供无参数构造方法。
* 习惯：如果自己手写有参数构造方法，
* 同时也不要忘记写一个无参数构造方法
4.类的继承 父子关系 “是”的关系
* <1>继承关键字 extends 还可以扩展
* <2>是否父类所有属性和方法都被继承？不是
* （1）构造方法不会被继承
* (2)方法和属性（包括protected关键字）可以被继承
* 方法和属性如果修饰符是public或protected 可以被继承
* <3>子类的每个构造方法隐式调用了父类的缺省的构造方法
* 是不是父类必须有无参数构造方法？不是
* 如果父类没有无参数构造方法，
* 子类必须每个构造方法显式指明调用父类某有参数构造方法
* <4>super(xxx)子类构造方法调用父类构造方法
* 默认子类构造方法中都有super(),调用父类无参数构造方法
* super()也必须写在子类构造方法的第一行
* 同一个构造方法中不可能同时出现super()和this()
* <5> super.xxx属性或方法 调用父类属性或方法 super(name,age,salary);
* super指向父对象
* <6>类只能单一继承 A—>B,A—>C错 A—>B—>C对
* 接口可以多继承
This与Super的区别：This.与Super的区别；This()和Super（）的区别
5. 多态 *一个对象就是一个对象类型
* 一个变量可以是多个类型
* 继承与重载不同，
* 继承的关系是在运行时确认的（指向java命令运行类时，确认对象是子对象还是父对象），
* 而重载则是在编译时确认的（两个方法是否构成重载，编译时就能识别语法）
* 多态出现形式：
父类型 子对象 Employee m = new Manager();
接口类型 实现类对象
6.InstanceOf操作符：是一个布尔操作符；判断一个对象是否是另一个类的实例
如：Employee是父类 Manager是子类
Employee e = new Employee();
Manager m = new Manager();
Employee m2 = new Manager();
Object o1 = e;
Object o2 = m;
m2 instanceof Employee //true
m2 instanceof Manager /true
7.类型转换
用InstanceOf操作符判断对象的类型；子类类型隐式的升级到父类类型；父类类型必须要强制转换才能降到子类类型
//强制类型转换 大---》小
Manager m3 = (Manager)o2;
//强制类型转换 大---》小 注意：对象是否真正能够转换过去
8.方法重写 Overridden
* 《1》是父子类中的两个方法 才能说子类中方法是否重写父类方法
* 《2》名称相同，参数列表相同，返回类型相同(基本上保证和父类方法一致)
* 《3》方法的可见性不能缩小（方法修饰符范围不能缩小）
* 《4》异常的抛出数量不能增加（异常个数 异常大小）
* 多态的多种形式最终能够表现出来，关键是子类重写父类方法
父类：
public class Animal {
protected void eat(){
System.out.println("Animal eat()");
}
}
子类
public class Dog extends Animal {
public void eat(){
System.out.println("Dog eat()");
}
public static void main(String[] args) {
Animal a = new Dog();
a.eat();
}
}
9.考题Overload和Override的区别
Overload是重载的意思，Override是覆盖的意思，也就是重写。
重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。
重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。
10.编写图形类Shape，
包括求面积的方法getArea（）方法，该方法实现就输出”Shape求面积方法“
编写长方形类Rectangle继承Shape类
定义长 宽 属性及setter getter方法
重写getArea方法，实现求面积并打印
编写圆形类Circle继承Shape
定义半径r 及 setter getter方法
重写getArea方法，实现求面积打印
编写测试类ShapeTest
main方法测试，创建一个Shape类型数组，初始化数组，包含Shape、Rectangle、Circle对象，然后循环该数组分别调用求面积方法测试。
public class Shape {
//要重写的方法getArea()
public void getArea(){
System.out.println("Shape求面积方法");
}
}
public class Rectangle extends Shape {
private double a;
private double b;
public double getA() {
return a;
}
public void setA(double a) {
this.a = a;
}
public double getB() {
return b;
}
public void setB(double b) {
this.b = b;
}
public Rectangle() {
super();
}
public Rectangle(double a, double b) {
super();
this.a = a;
this.b = b;
}
//重写基类的方法getArea()
public void getArea(){
System.out.println("长方形的面积是" +a*b);
}
}
public class Circle extends Shape {
private double r;
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
public Circle(double r) {
super();
this.r = r;
}
public Circle() {
super();
}
//使得小数点后面保留2位小数，并四舍五入
public double count(double x){
long lx=Math.round(x*100);
return lx/100.0;
}
//重写基类的方法getArea()
public void getArea(){
System.out.println("圆的面积是" + count(Math.PI*Math.pow(r, 2))); //Math.pow(r, 2)为r*r
}
}
public class ShapeTest {
public static void main(String[] args) {
//创建Shape、Rectangle、Circle对象并调用构造函数初始化
Shape s=new Shape();
Rectangle r=new Rectangle(4.0,5.0);
Circle c=new Circle(3.0);
//创建Shape类型的数组，用来存放Shape、Rectangle、Circle对象
Shape [] s1={s,r,c};
//循环数组s1分别调用Shape、Rectangle、Circle的求面积方法
for(Shape sh:s1){
sh.getArea(); //Shape求面积方法
//长方形的面积是20.0
//圆的面积是28.27
}
}
}
11.在10的基础上，在ShapeTest类中编写个getArea(。。。)方法，该方法可以传入Shape、Rectangle、Cricle任何类型对象，执行getArea（）方法
public class ShapeTest {
public void getArea(Shape s2){
s2.getArea();
}
public void getArea(Rectangle r1){
r1.getArea();
}
public void getArea(Circle c1){
c1.getArea();
}
public static void main(String[] args) {
ShapeTest st=new ShapeTest();
st.getArea(s);
st.getArea(r);
st.getArea(c);
}
}
12.编写唱片Track和时间Duration类 及测试类Driver
Write three classes:
Track, Duration and Driver.
Duration class has three fields, i.e. hours, minutes and seconds, and two overloaded constructors.
Track has two fields, i.e. title and duration which has Duration type, and get/set methods.
The Driver class has a main method to set track’s duration and then, print out the duration.
//Duration类
public class Duration{
private int hours;
private int minutes;
private int seconds;
public Duration(){}
public Duration(int hours,int minutes,int seconds){
this.hours=hours;
this.minutes=minutes;
this.seconds=seconds;
}
public Duration(int timeseconds){
hours = timeseconds/3600;
timeseconds = timeseconds-(hours * 3600);
minutes = timeseconds / 60;
timeseconds = timeseconds - (minutes * 60);
seconds = timeseconds;
}
public void sethours(int hours){
this.hours=hours;
}
public void setminutes(int minutes){
this.minutes=minutes;
}
public void setseconds(int seconds){
this.seconds=seconds;
}
public int gethours(){
return hours;
}
public int getminutes(){
return minutes;
}
public int getseconds(){
return seconds;
}
}
//类
public class Track {
private String title;
private Duration duration;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Duration getDuration() {
return duration;
}
public void setDuration(Duration duration) {
this.duration = duration;
}
public Track(String title, Duration duration) {
super();
this.title = title;
this.duration = duration;
}
public Track() {
super();
}
}
// 类Driver
public class Driver {
public static void main(String[] args) {
Duration da=new Duration(12345);
Track t=new Track("雪之光",da);
System.out.println(t.getTitle()+ "： " +da.gethours()+":" +da.getminutes()+":" +da.getseconds());
}
}
//输出 雪之光 0:42:14
2011.7.25 周一
1.抽象类
* 《1》有抽象方法的类，必须声明为抽象类
但是，抽象类中可以存在实现的方法，甚至抽象类中一个抽象方法也没有
* 《2》抽象类不能被实例化（不能new对象） AbstractTest at = new AbstractTest();
* 《3》可以声明一个变量是抽象类类型的 AbstractTest at = null;
* <4>是否子类继承抽象父类，必须重写父类中抽象方法吗？
不是，如果子类没有将父类所有抽象方法实现，子类也必须声明为抽象类：
抽象方法：没有{}实现体，直接；结束的方法
* 抽象方法必须有abstract修饰 public abstract void b();
* 有抽象方法的类，必须声明为抽象类 abstract class
2.接口--抽象类继续抽象，没有任何实现的方法就叫接口
* interface 关键字
* 《1》所有方法都抽象
定义方法时抽象abstract关键字可省略 public可省略
* 《2》接口中定义的所有的变量都会被定义成public final static的
//接口中变量都是 public final static的
public static final int i = 100;
等价于int j = 100;
* 《3》类不叫继承接口，而是实现接口 implements
* 注意：接口可以继承吗？
* 可以而且可以多重继承 一个接口可以继承(extends)多个接口
* 类实现接口，需要实现接口中所有抽象方法
* 一个类可以实现多个接口,语法 implements接口1,接口2,...
* 《4》接口不能new对象，但是可以作为一种类型声明变量
考题：abstract class和interface有什么区别?
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
3.<1>静态变量（类变量）：
静态变量被类的所有实例共享，不依赖任何一个对象 所有对象都是用一个静态变量
静态变量是类一旦被加载，就立刻初始化，没有创建对象，也可以直接使用
在类的外部直接存取，直接使用 类名.静态变量
静态变量可以不需要创建对象 直接类名.静态变量使用，也可以对象.静态变量来使用
所有对象共用一个静态变量,
所以任何一个对象将静态变量改变，其他对象调用的静态变量也改变
<2>成员变量(实例变量):
直接包含在类的{}内，非静态变量
<3> 静态代码块:
只被调用一次 类加载时，就立刻会调用，而且只调用一次
作用：一般完成静态变量的初始化工作或者完成类中程序只加载一次的功能代码
<4>普通代码块:
每创建一个对象，就会执行一次，而且在创建对象的构造方法之前执行
4.成员方法：必须先有成员对象 才能够使用成员方法
静态方法：静态方法也是在类加载时就初始化，可以没有对象，直接 类名.静态方法
静态方法初始化先于对象
由于静态方法先于对象初始化，所以不能够在静态方法中直接使用成员方法
由于静态方法先于对象初始化，所以不能够在静态方法中直接使用成员变量
静态方法可以直接使用静态变量
实例：
public class StaticTest {
//成员变量或实例变量
private int i;
//静态变量或类变量或全局变量
private static int b;
// 静态代码块
static{
//i=10;
System.out.println("静态代码块执行=====");
b = 10;
}
//普通代码块
{
System.out.println("普通代码块执行====");
}
public StaticTest(){
System.out.println("构造对象========");
}
//成员方法
public void a(){
b++;
b();
}
public void c(){
a();
}
//静态方法
public static void b(){
//this.a();错
//i++; 错
b++; 对
}
public static void main(String[] args) {
StaticTest st1 = new StaticTest();
StaticTest st2 = new StaticTest();
* 两个对象分别有自己的实例变量i
* st1.i=100 不会改变st2.i st2.i=10
st1.i = 100;
System.out.println(st1.i);
System.out.println(st2.i);
System.out.println(StaticTest.b);
System.out.println(st1.b);
System.out.println(st2.b);
st1.b = 1000;
System.out.println(st2.b);//1000
//静态方法可以直接调用静态方法
b();
}
}
5.要覆盖或重写父类静态方法，重写的方法必须是static静态的
我们准确叫做 隐藏父类静态方法
只有子类型子对象 时，才能真正将父类静态方法隐藏起
a.b(); //==》SuperA.b(); 所以没有将父类的静态方法完全隐藏
public class SubA extends SuperA {
public void a() {
System.out.println("Sub A a()");
}
public static void b(){
System.out.println("Sub A b()");
}
public static void main(String[] args) {
SuperA a = new SubA();
a.a();
a.b(); //==》SuperA.b(); 所以没有将父类的静态方法完全隐藏
}
}
6.final关键字
* 《1》如果变量前加final 就是常量
要求（1）值不能再改变
（2）声明时必须初始化
习惯：常量定义时字母都大写
* 《2》如果方法前加final该方法子类就不能重写
* 《3》如果类前面加final该类就不能被继承
7.访问控制：
简答题
1. 面向对象的软件开发方法用什么把数据和基于数据的操作封装在一起？ //类
2. 在一个类定义中，用什么描述对象的状态? //属性 用什么描述对象的行为?//方法
3. 什么方法是一个特殊的方法，用于对对象进行初始化？ //构造方法
4. 一个源程序文件中，能有多于一个的 public类吗? //不能源程序文件名=public类.java
5. 构造方法的方法名可由编程人员任意命名吗? //不能必须与类名相同
6. 类的构造方法名必须和类名相同吗？ //是
7. 构造函数有返回值吗? //没有，也没有void
8. 构造函数可以重载吗？ //可以
9. 如果一个类定义中没有定义构造方法，该类有构造函数吗？ //有，默认的不带参数的构造方法
10. 如果一个类定义中已经定义了构造方法，java还会给它定义缺省的构造方法吗？ //不会
11. 类的访问控制权有哪两种？ //public和default
12. 用什么修饰符修饰的方法称为静态方法? //static
用什么修饰符修饰的属性称为静态属性? //static
13. 静态属性和静态方法仅属于类的一个具体对象吗？它属于谁？
不是，属于类
14. static 变量能是 private变量吗？ //可以
15. 使用静态成员都能以什么做前缀？ //类名或对象
16. static方法中能有this引用吗？ //不能
17. 非static方法中可以有this引用吗？ //可以
18．static方法能处理非static成员吗？ //不能
19．非static方法能处理static成员吗？ //能
20. 类的私有属性和私有方法能不能被其子类直接访问? //是
填空题
1.下面是一个类的定义，请完成程序填空。
public class Myclass
{ int x, y;
Myclass ( int i, int j) //构造方法
{
x=i; y=j;
}
}
2. 下面是一个类的定义，请将其补充完整。
class Student
{
String name;
int age;
Student( String s, int i)
{
name=s;
age=i;
}
}
3.下面是一个类的定义，请将其补充完整。
class Myclass // 定义名为Myclass的类
{
static int var=666;
static int getvar()
{ return var; }
}
4.下面程序的功能是通过调用方法max（）求给定的三个数的最大值，
请将其补充完整。
public class Class1
{
public static void main( String args[] )
{
int i1=1234,i2=456,i3=-987;
int MaxValue;
MaxValue=i1;
System.out.println("三个数的最大值："+MaxValue);
}
public static int max(int x,int y,int z)
{ int temp1,max_value;
temp1=x>y?x:y;
max_value=temp1>z?temp1:z;
return max_value;
}
}
写出下列程序的输出结果
public class Test
{
public static void main(String[] args)
{
Count myCount = new Count(); //无参数 count =1
int times = 0; //成员变量
for(int i=0;i<100;i++)
increment(myCount , times);
System.out.println("count is" + myCount.count);
System.out.println("time is"+ times);
}
public static void increment(Count c , int times) //静态方法
{
c.count++;
times++;
}
}
class Count
{
public int count;
Count(int c)
{
count =c;
}
Count()
{
count =1;
}
}
结果：count is 101
time is 0
编写一个类，要求使用单例模式
提示：单例模式就是这个类在使用时候只能new一个对象,多个实例都是一个对象引用
public class Singleton {
private static Singleton s;
private Singleton(){
System.out.println("A Singleton Model example");
}
public static Singleton getInstance() {
if(s==null)
s=new Singleton();
return s;
}
public static void main(String[] args) {
Singleton s=Singleton.getInstance();
}
}
2011.7.26 周二
1.类的访问控制权有public和default
2.单例模式实例：
单例模式就是这个类在使用时候只能new一个对象,多个实例都是一个对象引用
public class Singleton {
//1 构造方法私有化
private Singleton(){}
//3 声明一个该类类型的静态变量
private static Singleton s ;
//2 提供一个公有的 static返回该类类型的方法
public static Singleton getInstance(){
if(s==null)
s = new Singleton();
return s;
}
}
public class SingletonTest {
public static void main(String[] args) {
Singleton st1 = Singleton.getInstance();
Singleton st2 = Singleton.getInstance();
System.out.println(st1==st2); //true同一个对象
}
}
3.==与equals()的区别：
* ==比较值相等
原始类型比较值大小 引用类型比较对象地址
* equals(Object o)方法
判定两个对象是否具有相同的类型和内容
* equals()方法是Object类的方法 等价于== 比较对象地址
* 如果自己的类，必须重写equals()方法
* 约定：重写equals（）方法，应该同时重写hashCode（）方法
* 达到两个对象相等，应该对象的哈希码也相同
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
实例：
public class EqualsTest {
public static void main(String[] args) {
int x =10;
int y =10;
System.out.println(x==y); //true
Student s1 = new Student("z3",20);
Student s2 = new Student("z3",20);
System.out.println(s1==s2); //false
System.out.println(s1.equals(s2)); //true
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
//考题：
String str1 = "abc";
String str2 = new String("abc");
String str3 = "abc";
System.out.println(str1==str2); //false
System.out.println(str1.equals(str2));//true
System.out.println(str1==str3); //true
System.out.println(str1.equals(str3));//true
}
}
4.toString()方法
* 作用：对象转换为字符串时调用 直接打印对象时默认会调用
* 当打印一个对象的时候，隐式调用对象的toString()方法
* 一般要重写toString()方法。
@Override
public String toString() {
return "学生名："+this.name+"\t学生年龄："+this.age;
}
//println(String s)
System.out.println(s1.toString());
//println(Object o)
System.out.println(s1);
5.按照上课讲的实例开发
Track唱片类
Duration时间封装类 要求构造方法有传递总时间的构造方法
TrackTest测试类
测试打印唱片Track对象和Duration对象可以直接打印（重写toString方法）
要求打印时间为 hh:mm:ss的格式
public class Duration {
private int hours;
private int minutes;
private int seconds;
public int getHours() {
return hours;
}
public void setHours(int hours) {
this.hours = hours;
}
public int getMinutes() {
return minutes;
}
public void setMinutes(int minutes) {
this.minutes = minutes;
}
public int getSeconds() {
return seconds;
}
public void setSeconds(int seconds) {
this.seconds = seconds;
}
public Duration(int hours, int minutes, int seconds) {
this.hours = hours;
this.minutes = minutes;
this.seconds = seconds;
}
//传递总时间的构造方法
public Duration(int total){
this.hours = total/3600;
this.minutes = total%3600/60;
this.seconds = total%60;
}
//保证为2位数
public String format(int x){
if(x<10)
return "0"+x;
else
return " "+x;
}
//重写object的toString()方法
控制 hh:mm:ss的格式
public String toString(){
if(hours==0)
return format(minutes)+":"+format(seconds);
else
return format(hours)+":"+format(minutes)+":"+format(seconds);
}
}
public class Track {
private String title;
private Duration duration;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Duration getDuration() {
return duration;
}
public void setDuration(Duration duration) {
this.duration = duration;
}
public Track(String title, Duration duration) {
this.title = title;
this.duration = duration;
}
public Track(String title) {
super();
this.title = title;
}
public Track(Duration duration) {
super();
this.duration = duration;
}
public Track() {}
//重写object的toString()方法
public String toString(){
return title+" "+duration;
}
}
public class TrackTest {
public static void main(String[] args) {
Duration da=new Duration(12345);
Track t=new Track("雪之光",da);
System.out.println(t); //输出 雪之光 03: 25: 45
}
}
6.String类
（1）分割字符串 split(String s) 根据给定正则表达式的匹配拆分此字符串。
String str1 ="1abc_9bcd_12df3_45se6";
String [] str1s= str1.split("_");
for(String st:str1s){
System.out.println(st); //返回1abc 9bcd 12df3 45se6
（2）取子串 String substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串。
该子字符串从指定索引处的字符开始，直到此字符串末尾
String substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1处的字符,
该子字符串的长度为 endIndex-beginIndex
String str1 ="1abc_9bcd_12df3_45se6";
String subStr1 = str1.substring(3,16);
System.out.println(subStr1); //返回 c_9bcd_12df3_
(3)boolean contains(CharSequence s)
当且仅当此字符串包含指定的 char值序列时，返回 true。
String str1 ="1abc_9bcd_12df3_45se6";
boolean bl = str1.contains("d");
（4）public int indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引。
如果字符串参数作为一个子字符串在此对象中出现，则返回第一个这种子字符串的第一个字符的索引；
如果它不作为一个子字符串出现，则返回 -1。
String str1 ="1abc_9bcd_12df3_45se6"
int index = str1.indexOf("d");
System.out.println(index); //返回8
（5） boolean equals(Object anObject)
将此字符串与指定的对象比较。
String s1 = new String("Hello");
String s2 = s1;
String s3 = new String("Hello");
System.out.println("s1.equals(s3):" + s1.equals(s3)); //true
(6)忽略大小写比较相等 public boolean equalsIgnoreCase(String anotherString)
将此 String与另一个 String比较，不考虑大小写。如果两个字符串的长度相同，
并且其中的相应字符都相等（忽略大小写），则认为这两个字符串是相等的。
String code ="aBcD";
String myCode ="abcd";
if(code.equalsIgnoreCase(myCode)){
System.out.println("验证码正确"); //验证码正确
}
（7）char charAt(int index)
返回指定索引处的 char值。索引范围为从 0到 length() - 1
String str1 ="1abc_9bcd_12df3_45se6";
char c= str1.charAt(3);
System.out.println(c); //返回c
（8）int compareTo(String anotherString)
按字典顺序比较两个字符串。
如果按字典顺序此 String对象位于参数字符串之前，则比较结果为一个负整数。
如果按字典顺序此 String对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为 0；
String str1 ="1abc_9bcd_12df3_45se6";
String str2 ="1abc_9bcd_12df3_45se6";
int j=str1.compareTo(str2);
System.out.println(j); //返回0
（9） String concat(String str)
将指定字符串连接到此字符串的结尾。
如果参数字符串的长度为 0，则返回此 String对象。否则，创建一个新的 String对象，
用来表示由此 String对象表示的字符序列和参数字符串表示的字符序列连接而成的字符序列。
String str3 ="1abf3_";
String str4 ="45se6";
String s=str3.concat(str4);
System.out.println(s); //返回 1abf3_45se6
（10） boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束。
如果参数表示的字符序列是此对象表示的字符序列的后缀，则返回 true；否则返回 false。
注意，如果参数是空字符串，或者等于此 String对象（用 equals(Object)方法确定），则结果为 true。
String str4 ="45se6";
boolean b=str4.endsWith("se6");
System.out.println(b); //返回True
(11) String trim()
返回字符串的副本，忽略前导空白和尾部空白。
此字符串移除了前导和尾部空白的副本；如果没有前导和尾部空白，则返回此字符串。
String str5 =" 1abf3_ ";
String s2=str5.trim();
System.out.println(s2);//返回1abf3_
7.StringBuilder类
String 常量不可变
* 当程序频繁改变字符串 不用使用String的 +运算
* 应该使用StringBuffer 线程安全的可变字符序列。一个类似于 String的字符串缓冲区
StringBuilder
* 一个可变的字符序列。此类提供一个与 StringBuffer兼容的 API，
* 但不保证同步。该类被设计用作 StringBuffer的一个简易替换
String str3 = "abc";
//str3 = str3+"def"; 不可取
(1)StringBuffer append(StringBuffer sb)将指定的 StringBuffer添加到此序列中。
String str3 = "abc";
StringBuffer buffer = new StringBuffer(str3);
buffer.append("def");
System.out.println(buffer.toString()); //abcdef
8.StringBuilder类
（1）StringBuffer replace(int start, int end, String str)用字符串str代替start和end之间的字符。
public class StringBuilderTest {
public static void main(String[] args) {
String str1="ashghgh_";
System.out.println(str1); //ashghgh_
StringBuilder sbt=new StringBuilder(str1);
StringBuilder sb=sbt.replace(1, 1, "12gyuopp");
System.out.println(sb); //a12gyuoppshghgh_
}
}
9.Date类
public class DateTest {
public static void main(String[] args) {
//时间 Date
Date d = new Date();
System.out.println(d);
//Calendar日历 提供更加强大的时间操作
//DateFormat时间格式化 抽象类 子类SimpleDateFormat
//2011-07-26 10:33:36 时间格式化
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
String dStr = sdf.format(d);
System.out.println(dStr);
//"2011-07-26"
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
try {
Date d2 = sdf2.parse("2011-07-26");
} catch (ParseException e) {
e.printStackTrace();
}
}
}
10.DateFormat类：是抽象类，找子类SimpleDateFormat
（1） static DateFormat getDateInstance()
获取日期格式器，该格式器具有默认语言环境的默认格式化风格。
String dateString = "20110724";
try {
Date date= new Date();
SimpleDateFormat sdf3=SimpleDateFormat("yyyyMMdd");
System.out.println(sdf3.parse(dateString));
//下面将字符串转换为日期格式后显示的格式是2008-10-12
System.out.println(DateFormat.getDateInstance().format(date));
//如果想换一种别的格式，可以用下面的办法，得到任何的日期格式都可以
//输出的结果为2010/07/24
System.out.println(new SimpleDateFormat("yyyy/MM/dd").format(date));
//SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");
//输出的结果为2011年07月24日
System.out.println(new SimpleDateFormat("yyyy年MM月dd日").format(date));
} catch (Exception ex) {
System.out.println(ex.getMessage());
}
}
11.Math类
（1）static int abs(int a) 返回 int值的绝对值。
int i=-12;
System.out.println(Math.abs(i)); //12
(2)static double ceil(double a)
返回最小的（最接近负无穷大）double值，该值大于等于参数，并等于某个整数。(会四舍五入)
double j=-124.32;
double h=234.56;
System.out.println(Math.ceil(j)); //-124.0
System.out.println(Math.ceil(h)); //235.0
（3） static double random()
返回带正号的 double值，该值大于等于 0.0且小于 1.0。
System.out.println(Math.random()*10+1);//产生1-10之间的随机数7.99223411269374
12.编程，产生随机数1-10 循环50次，统计出现的数字及个数
public class RandomTest {
public static void main(String[] args) {
int A[] = new int[11];
for(int i=1;i<=50;i++){
int random = (int)(Math.random()*10+1);
for(int j=1;j<=10;j++){
if(random == j){
A[j] ++;
}
}
}
for(int i=1;i<=10;i++){
System.out.println("数字"+i+ "出现了:"+A[i]+"次");
}
}
}
结果：数字1出现了:4次
数字2出现了:5次
数字3出现了:6次
数字4出现了:3次
数字5出现了:7次
数字6出现了:4次
数字7出现了:2次
数字8出现了:4次
数字9出现了:10次
数字10出现了:5次
13.字符串String str ="asdfghjkl";编写程序将该字符串逆序输出
public class StringTest {
public static void main(String[] args) {
String str ="asdfghjkl";
char[] cs=str.toCharArray();
for(int i=cs.length-1;i>=0;i--){
System.out.print(cs[j]);
}
}
}
或：public class StringBufferTest {
public static void main(String[] args) {
String str ="asdfghjkl";
StringBuffer buffer = new StringBuffer(str);
buffer.reverse();
System.out.println(buffer);
}
}
14.原始类型对应的包装类型
八种原始类型 对应都有各自的包装类型
包装类型作用：
*《1》类型转换 比如 String--->int String-->float
*《2》得到原始类型对应的类类型对象
实例：public class WrapperClass {
public static void main(String[] args) {
int i = 10;
//打包
Integer integer = new Integer(i);
String s = " 10 ";
String ss = s.trim();// "10"
//String--->int
//步骤1 String-->Integer--->int
Integer is = new Integer(s.trim());
int x = is.intValue();
//步骤2 String--->int
int y = Integer.parseInt(s.trim());
System.out.println(y);
//其他 例如 String ---》float
String s2 ="1.2";
float f = Float.parseFloat(s2);
/**
* 新特性 自动打包和拆包
*/
//Integer is2 = new Integer(10);
Integer is2 =10;
int m = is2;
}
}
14.在第二题基础上， 将字符串封装为Track对象 并输出 “唱片1, 390”
public class Duration {
private int hours;
private int minutes;
private int seconds;
public int getHours() {
return hours;
}
public void setHours(int hours) {
this.hours = hours;
}
public int getMinutes() {
return minutes;
}
public void setMinutes(int minutes) {
this.minutes = minutes;
}
public int getSeconds() {
return seconds;
}
public void setSeconds(int seconds) {
this.seconds = seconds;
}
public Duration(int hours, int minutes, int seconds) {
this.hours = hours;
this.minutes = minutes;
this.seconds = seconds;
}
public Duration(int total) {
this.seconds =total;
}
public String toString(){
return seconds+"";
}
}
public class Track {
private String title;
private Duration duration;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Duration getDuration() {
return duration;
}
public void setDuration(Duration duration) {
this.duration = duration;
}
public Track(String title, Duration duration) {
this.title = title;
this.duration = duration;
}
public Track(String title) {
super();
this.title = title;
}
public Track(Duration duration) {
super();
this.duration = duration;
}
public Track() {}
public String toString(){
return title+" "+duration;
}
}
public class TrackTest {
public static void main(String[] args) {
String str="唱片1, 390";
String [] s= str.split(",");
int y = Integer.parseInt(s[1].trim());
Duration d=new Duration(y);
Track t=new Track(s[0],d);
System.out.println(t);
}
}
输出：唱片1 390
15.System类
（1）static long currentTimeMillis()
返回以毫秒为单位的当前时间。
当前时间与协调世界时 1970年 1月 1日午夜之间的时间差（以毫秒为单位测量）。
public class Test {
public static void main(String[] args) {
long now = System.currentTimeMillis();
System.out.println(now); //1311727788672
}
}
2011.7.27 周三
1.内部类：在一个类中声明另一个类（A类中声明B类，则B是A得内部类）
作用：（1）在A中的成员变量，在B方法中可以直接使用成员变量(方便访问类中的局部变量和私有变量)
（2）避免类名命名冲突
（3）在图形界面编程中常使用
分类：成员内部类、静态内部类、局部内部类、匿名内部类
（1）静态内部类
* 内部类最简单的形式
* 不能和外部包围类使用相同名称
* 编译成独立的类，外部类和内部类分开StaticOuterClass.class和 StaticOuterClass$StaticInnerClass.class
* 只能访问外部类的静态成员或者方法，包括私有的
* 看成静态方法
* 静态内部类创建实例语法：外部类.内部类 变量 = new外部类.内部类();
实例：
public class StaticOuterClass {
private static int i = 10;//成员变量
private int b = 10;
public void a(){
i++;
System.out.println(i); //11
}
public static void b(){
//i++;
}
static class StaticInnerClass{ //静态内部类
private int i = 8;
public void a(){
int j=StaticOuterClass.i++; //访问外部的i变量
System.out.println(j); //11
i++; //操作内部的i变量
System.out.println(i); //9
}
}
}
public class StaticInnerClassTest {
public static void main(String[] args) {
StaticOuterClass outer = new StaticOuterClass(); //创建外部类对象
StaticOuterClass.StaticInnerClass inner = new StaticOuterClass.StaticInnerClass();
//创建静态内部类对象
outer.a();
inner.a();
}
}
（2）成员内部类 和成员变量成员方法平级
* 不使用Static修饰符在包围类中定义
* 像成员变量
* 可以访问包围外部类的所有成员
在内部类中访问包围类的成员的语法：Outerclass.this.member 外部类.this.外部类变量
在外部类创建成员内部类对象语法：外部类.内部类 inner = new外部类(). new内部类();
实例：
public class MemberOuterClass {
private int i = 10;
public void a(){
this.i++;
System.out.println(i); //11
}
class MemberInnerClass{
private int i = 8;
public void innerA(){
i++; //自己的 8
System.out.println(i); //9
//new MemberOuterClass().i++;错误的
this.i++;//自己的 8
System.out.println(i); //10
int j=MemberOuterClass.this.i++;//外部类当前对象 外部类.this
System.out.println(j); //10
}
}
}
public class MemberInnerClassTest {
public static void main(String[] args) {
MemberOuterClass outer=new MemberOuterClass();
outer.a();
MemberOuterClass.MemberInnerClass inner =new MemberOuterClass().new MemberInnerClass();
inner.innerA();
}
}
（3）局部内部类
*在方法内定义，甚至就是方法内的代码块
* 内部类中最不常用的形式
* 像局部变量，但不能声明成public,protected,private,static
* 只能访问final的局部变量 ==》如果访问成员变量，可以直接方法
如果访问局部变量，局部变量必须是final的常量
实例：
public class LocalOuterClass {
private int i =10;
public void a(final int x){
//x++; //错误：x是常量不能改变值
i++;
System.out.println(i); //11
final int b =8;//局部变量
class LocalInnerClass{
public void a(){
i++;//错误，不能访问非final的常量
int y = b; //局部变量必须是final的常量8
y = x; //传入的值
}
}
}
}
（4）匿名内部类
* 局部内部类的一种特殊形式
* 直接访问final的局部变量
* 没有class关键字 没有类名
* 没有extends/implements关键字
* 只用一次，必须指明变量初值
* 通常都是隐式的继承父类 或 实现接口
* 下面例子 开发一个匿名内部类隐式的实现了Shape接口
* 并且同时创建了一个匿名内部类对象，他的类型是Shape类型的
* 匿名内部类：
优点：代码编写简单
缺点：很难理解
* 总结：
new 抽象父类/接口(){
大括号包含的就是匿名内部类
}
实例：
public interface Shape { //定义一个Shape接口
public void area();
}
public class UseShape {
public void area(Shape s){
s.area();
}
public static void main(String[] args) {
UseShape us = new UseShape();
us.area(new Shape(){ //匿名内部类
private double r=3;
@Override
public void area() {
System.out.println("圆形面积:"+(Math.PI*r*r));
}
});
}
}
2.练习内部类的使
<1>编写Shape接口，包含getArea()方法
<2>编写ShapeTest类，该类中有方法 getArea(Shape s){ s.getArea();}
main方法中测试，调用该getArea(Shape s）方法，
要求传递参数s的值对象是通过成员内部类、静态内部类、匿名内部类的对象
publicinterface Shape {
publicvoid getArea();
}
publicclass ShapeTest {
publicvoid getArea(Shape s){
s.getArea();
}
//成员内部类
class Circleimplements Shape{
privatedoubler=7;
publicvoid getArea() {
System.out.println("成员内部类：圆的面积是 "+(int)Math.PI*r*r); }
}
//静态内部类
staticclass Recgiterimplements Shape{
privatedoublew=6;
privatedoublel=6;
@Override
publicvoid getArea() {
System.out.println("静态内部类：长方形的面积是 "+w*l);
}
}
publicstaticvoid main(String[]args) {
ShapeTest st=new ShapeTest();
//匿名内部类
st.getArea(new Shape (){
privatedoubler=5;
@Override
publicvoid getArea() {
System.out.println("匿名内部类：圆的面积是 "+(int)Math.PI*r*r); }
});
st.getArea(new ShapeTest2().new Circle());
st.getArea(new ShapeTest2.Recgiter());
}
}
3.比较2个学生
（1)在Student类中实现接口Comparable,重写compareTo抽象方法
public int compareTo(Student o) {
return this.age-o.getAge();
}
在测试类中：
public Student min(Student s1,Student s2){
return s1.compareTo(s2)>0?s2:s1;
}
(2)直接在测试类中：匿名内部类
StudentTest st = new StudentTest();
Student s1 = new Student("zhangsan",20);
Student s2 = new Student("lisi",30);
class StudentComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();
}
}
4.集合框架：一个集合就是可以并只能存放其它对象的特殊对象
Java中实现集合功能需要实现三个元素
集合与数组的区别：
（1）数组定长，集合可变长
（2）数组只能存放一种类型，集合可以存放多种类型，只要是对象就可以
习惯：一个集合中只存放同一种类型对象
接口：定义每一种集合形式必须实现的方法
实现：具体的实际类如：Hashtable,Vector
算法：存储、获得以及操作集合众元素的方法
注意：Package java.util在java.util包中
集合接口框架：分为两类：Collection接口和Map接口（结构不同分） ,
其中Collection接口分为List接口和Set接口（算法不同分），
Set接口包含Sortedset,
Map接口包含SortedMap接口（Map是Key,value键字，key不能重复作为主键，）
Set不允许存放相同的对象（有相同的对象不添加）、元素是无序的。
Sortedset和Set类似，但在Sortedset集合中的元素是有序存储的。
List元素是有序的，按照添加元素的顺序保持，删除元素时也保证元素是连续有序的，并且允许存储重复的对象。
Map通过唯一的主键和值的影射来存放对象、不允许有相同的主键。无序的，
有相同的Key,value值会覆盖，value可以重复，只能根据key取value值。
SortedMap和Map类似，但存放主键是默认按照升序的方式存放，借此保证对象的有序。只按Key排序
集合框架中类的层次关系：分为两类：Collection下包含HashSet[Set]类和LinkedList、Vector、ArrayList[List]
HashSet下包含TreeSet[Sortedset];Hashtable、HashMap[Map]下包含TreeMap[SortedMap].
5.开发一个最简单的集合练习类ListTest 练习使用ArrayList集合对应的方式使用一下Vector和LinkedList集合
import java.util.*;
import simple.Student;
public class ListTest {
public static void main(String[] args) {
//1 选择自己想用的集合 创建对象
List list1= new ArrayList(); //ArrayList
List list2 = new Vector(); //Vector
List list3 = new LinkedList(); //LinkedList
//2.添加元素
list1.add("abc");
list1.add(123);
list1.add(12.9);
list1.add(new Student());
list2.add("abc");
list2.add(new ShapeTest());
list2.add(9.0);
list2.add(63);
list3.add("abc");
list3.add(new ShapeTest());
list3.add(9.0);
list3.add(63);
System.out.println(list1.get(0));
System.out.println(list1.size());
System.out.println(list2.get(1));
System.out.println(list2.size());
System.out.println(list3.get(2));
System.out.println(list3.size());
//取值
System.out.println(list1);
System.out.println(list2);
System.out.println(list3);
//取值
for(int i=0;i<list1.size();i++){
Object o1 = list1.get(i);
System.out.println(o1);
}
for(int j=0;j<list2.size();j++){
Object o2 = list2.get(j);
System.out.println(o2);
}
for(int k=0;k<list3.size();k++){
Object o3 = list3.get(k);
System.out.println(o3);
}
}
}
6.编写一个学生类Student
编写一个学生业务类StudentBO，
该类编写一个集合属性List students， setter getter方法
编写一个方法添加学生方法，将一个学生添加到属性students中
实现时要求集合存在相同的学生不添加，不存在相同的添加学生
编写一个StudentBOTest类，测试添加学生方法
public class Student implements Comparable<Student> {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public Student() {}
public String toString(){
return name+ " "+age;
}
//按照学生年龄升序排列 如果年龄相同 按照名字降序
@Override
public int compareTo(Student o) {
if(this.age!=o.getAge()){
return this.age-o.getAge();
}else{
return -this.name.compareTo(o.getName());
}
}
@Override
public int hashCode() {
return this.name.hashCode()+this.age;
}
@Override
public boolean equals(Object obj) {
Student s = (Student)obj;
if(this.name.equals(s.getName())&&this.age==s.getAge())
return true;
return false;
}
}
import java.util.*;
public class StudentBO {
List<Student> students;
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
public StudentBO(List<Student> students) {
this.students = students;
}
public StudentBO() {}
public void addStudent(Student s){
if(!students.contains(s))
students.add(s);
}
public String toString(){
return students+ " ";
}
}
import java.util.*;
public class StudentBOTest {
public static void main(String[] args) {
Set<Student> set = new HashSet<Student>();
Student s1 = new Student("zhangsan",14);
Student s2 = new Student("lisi",21);
Student s3 = new Student("wangwu",22);
Student s4 = new Student("zhangsan",14);
Student s5 = new Student("gaoxing",43);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
Iterator<Student> it= set.iterator();
while(it.hasNext()){
Student s=it.next();
System.out.println(s);
}
}
}
- java学习笔记-1
- Java学习笔记1
- java学习笔记(1)
- java学习笔记1
- Java学习笔记1
- java学习笔记1
- java学习笔记(1)
- Java学习笔记1
- java学习笔记(1)
- JAVA学习笔记1
- java学习笔记1
- Java学习笔记(1)
- java学习笔记1
- JAVA学习笔记 1
- JAVA学习笔记(1)
- java学习笔记1
- java学习笔记 1
- java 学习笔记《1》
- MongoDB分片群集（windows）
- 女维护工程师 巾帼不让须眉
- 入学三个月后……
- 深入研究Servlet线程安全性问题
- 第五周任务2
- JAVA学习笔记1
- 修改AlertDialog的大小
- 制作jffs2文件系统时遇到的错误————转载
- 今日主题--卡尔曼滤波器
- C++利用队列（Queue）求解迷宫（Maze）中指定起点和终点间是否有最短路径，如果有的话输出所需步数，如果没有输出
- 重构—改善代码既有设计 之if/else使用
- Linux中SVN的安装和配置
- 自定义dialog
- 《探索发现》历年目录节目单总汇
