笔记
1、定义一个年份判定这个年是否是闰年：
import class near {
public static void main(String args[])throws IOException{ int year;
String str;
BufferedReader buf;
buf=new BufferedReader(new InputStreamReader);
"Input the year:");
str=();
year=(str);
if(year%4==0&&year%100!=0||year%400==0)
"year"+year+"is a leap year.");
else
"year"+year+"is not a leap year.");
}
}
2、求出1~100之间的奇数：
public class qishu {
public static void main(String args[]){
int i,j;
for(i=1;i<=100;i++){
if(i%2!=0){
" ");
}
}
}
}
3、一段刚才长2000米每天截取一半多少天后长度短于5米public class day {
public static void main(String args[]){
int i ,j=0;
for(i=2000;i>0;i--){
if(i/2<5)
j++;}
" ");
}
}
4、求125的所有因子：
public class yinzi {
public static void main(String args[]){
int i;
for(i=1;i<=125;i++){
if(125%i==0){
" ");
}
}
}
}
5、同类型字符串转换int 输出：
import .*;
public class zhuanhuan {
public static void main(String args[])throws IOException{ BufferedReader buf;
"请输入: ");
buf=new BufferedReader(new InputStreamReader);
String str=();
"您输入的内容为："+str);
int number = (str);
number=number+2;
"转换后为："+number);
}
}
课程
一·输出结果：
int a[]={1,2,3,4};
int b[]={100,200,300,400,500};
b=a;
现在b里变成0xaa
要找求那个数组的长度找b0 =1
变量放地址地址就是首地址就能找到了
结果为：4
1
二·数组的声明与输出：
public class bb {
public static void main(String[] args) {
2010年3月18日
判断下列运行：
1、String s1="abc"+"def";
2、String s2=new String(s1);
3、if(s1==s2)
4、"==succeeded");
5、if(s2))
6、".equals()succeeded");
行6执行，行4不执行
***思考：怎样调整***
13:36 2010-3-23——JAVA课程笔记
第四章·Java的面向对象程序设计
一·什么是对象（P89）
1、对象具有的特性：
（1）万物皆为对象
（2）每个对象都是唯一的（每个对象分配的内存地址不同）
（3）对象具有属性和行为
（4）对象具有状态，某个瞬间对象的各个属性的取值。
2、EG：张三 01号 21岁上课吃饭睡觉
属性：姓名学号年龄
动作：上课吃饭睡觉
行为是某一个属性瞬间的状态
3、EG：当在同一文件里时，只把文件名与公共类名（Test8）保持一致：class Student {
String name;
int age;
int number;
void study(){
"我来511上课");
}
void eat(){
"中午吃的包子");
}
void sleep(){}
}
public class Test8 {
public static void main(String args[]){
Student zhangsan = new Student();
();
();
Student lisi = new Student();
();
}
}
二·什么是类：（P89）
类是一组具有相同属性和行为的对象的集合
4·1·2 类和对象的关系：
1、区别
*类是一个抽象的概念，对象是具体的事物
【类是一个模板一个规则；对象是模板创造出来真实的东西】
2、联系
*对象都属于某一个类
*同一个类的所有对象具有相同属性，属性值不一定相同，但行为都相同。【行为由代码体现的】
4·2 类的创建（P90）
1、类的声明格式
class 类名称{
类主题
}
2、类的语法格式
class类名{ 【类名尽量大写】
变量类型变量名
返回类型方法名（参数）{方法体} 【对行为的描述】
}
3、EG：学生类的创建
public class student {
String name;
int age;
int number;
void study(){
void eat(){};
void sleep(){};
}
【类建立完了要进行对象的扩充，当有数据传输时才有对象的输出】
4·3·1 对象的创建（P93）
1、语法格式
类名对象名=new 类名（）；
2、EG: student zhangsan = new student();
【String name 是定义字符串的东西】
六·面向对象程序设计的核心技术
面向对象程序设计的核心技术是：封装（P98）、继承（P103）和多态性（P110）
4·4 封装：封装是把对象的属性和行为组合成为一个独立的单位或部件，并尽可能隐蔽对象的内部细节，而只保留必要的对外接口，使之与外部发生联系。
4·5 继承：
class Car{
int color_number;
int door_number;
int speed;
brake(){...};
speedUp(){...};
}
class Trash_Car
sxtends Car
{
Fill_trash(){…}
}
4·6 多态性：
同一个消息可以根据发送消息对象的不同产生多种不同的行为方式。
【猫和狗都会叫但声音不同这就是多态性】
七·类的声明
4·2·1 类的声明格式
Class 类名称{
类主体
}
?类首声明定义了类的名字、访问权限与其它类的关系等。
?类主体定义了类的成员，包括变量（数据）和函数（方法）
1、类首的声明：
[<修饰符>]class<类名>[extends<超类名>][implements<接口名>]【<>的内容可省】?class: 类定义的关键字；
?extends: 表示类和另外一些类（超类）的继承关系；
?implements: 表示类实现了某些接口；
?修饰符: 表示类访问权限（public、private等）和一些其它特性（abstract、final等）；
EG：public class Data
声明Date1类，访问权限为Public，表示类Date1可以被该类所属的包之外的类使用。
2类主体
<类首声明>
{
<成员变量的声明>
<成员方法的声明及实现>
}
?成员变量即类的数据，反映了类的属性和状态。
?成员方法即类的行为（对数据的操作）
4·2·2 成员变量
[<修饰符>] [static] [final] [transient] <变量类型> <变量名>
static: 表示是一个类变量（静态变量）；
final: 表示是一个常量；
transient: 表示一个临时变量
修饰符: 表示变量的访问权限（缺省访问、public、protected和private）
4·2·3 成员方法：
[<修饰符>] <返回类型> <方法名> ([<参数表列>])[throws <异常类>]
{ 方法体 }
修饰符：方法的访问权限(缺省的、public、protected和private)
static: 类方法（静态方法）；
abstract: 抽象方法（无方法体的方法）；
final: 最终方法（不能被子类改变）。
throws: 表示抛出异常
定义一个梯形类其中定义4个double类型变量上底下底高梯形面积用一个方法求面积public class sj{
double up;
double down;
double height;
double area;
double tarea(){
area=(up+down)*height/2;
return area;
}
}
笔记（把几天的合在一起了、有点乱~）
4.2.4 成员变量和局部变量区别
成员变量：变量定义部分所定义的变量。
局部变量：在方法体中定义的变量和方法的参数。
区别：
1.成员变量在整个类内都有效，局部变量只在定义它的方法内有效。成员变量与他书写的位置无关
2.如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，即这个成员变量在这个方法内暂时失效 .这时如果想在该方法内使用成员变量，必须使用关键字this。
4.3.1 创建对象
第一种形式：
（1）声明对象
<类名> <对象名>
作用：声明一个引用变量，仅仅是预定变量的存储空间，并没有对象实体生成，此时的对象被称作空对象。（2）实例化对象（new）
<对象名> = new <类名>（）
作用：在内存中为此对象分配内存空间，并返回对象的引用（即对象的存储地址）。
<对象名> = new <类名>（）
系统做的两件事：
1.为各个成员变量分配内存，然后执行构造方法中的语句。如果成员变量在声明时没有指定初值，所使用的构造方法也没有为成员变量进行初始化操作，那么，根据变量的类型给出默认值。
2.给出一个信息，确保这些变量是属于该对象的。返回一个号码，这个号码包含着代表这些成员变量内存位置的首地址等重要的有关信息给该对象。
第二种形式：声明对象的同时，将它实例化
<类名> <对象名> = new <类名>（）
实例化就是为对象分配存储空间，并同时对对象进行初始化。这些工作分别用new运算符和类的构造方法来完成。
创建多个不同的对象
一个类通过new运算符可以创建多个不同的对象，这些对象将被分配不同的内存空间。因此，改变一个对象的状态不会影响其他对象的状态。
Student 张三 = new Student（）；
Student 李四 = new Student （）；
4.3.3 对象的使用
引用成员变量或成员方法时要用“.” 运算符
?成员变量的引用格式：
<对象名>.<变量名>
?成员方法的调用格式：
<对象名>.<方法名([参数])>
4.3.2 构造方法和对象的初始化
构造方法是一种特殊的方法，类的构造方法可以使我们在创建对象时进行初始化（对成员变量赋初值）。
当用new创建一个类的新的对象时，构造方法就立即执行。
如果不想进行初始化，就调用类的默认构造方法。
1.默认的构造方法
类名(){ }
Student(){}
2.如何创建构造方法
构造方法名字必须与类名相同。
构造方法没有返回值（在构造方法名字前
连void也不要加）
注意：除了构造方法，在类中不能出现与类名相同的方法。
3、无参数的构造函数
如果有自己创建的构造函数，而创建某些对象时又不想进行初始化，一定要在类中创建无参数的构造函数，因为此时已没有缺省的构造函数了。
4.3.4 对象的销毁
对象销毁的方法
<修饰符> void finalize（）{方法体}
finalize方法没有参数，没有返回值，且一个类只能定义一个finalize方法。
注意：该方法的运行发生在对象销毁之前。
笔记
class Student{
String name;
int age;
int number;
Student(String x,int y,int z){
name=x;
age=y;
number=z;
}
void study(String course){
"我在学习"+course);
}
void eat(){}
void sleep(){}
}
public class StudentTest{
public static void main(String arge[]){
Student zhangsan=new Student("zhangsan",23,5);
" "++" "++" ");
("yingyu");
}
}
运行结果：
zhangsan 23 5
我在学习yingyu
EG：设计一个长方形类，成员变量包括长和宽。类中有计算面积和周长的方法；有构造函数，为长方形的长和宽赋值。、定义一个测试类，并输出长方形的周长和面积。【K】
class ZCMJ{
double chang;
double kuan;
String zhouchang;
String mianji;
ZCMJ(int x,int y){
chang=x;
kuan =y;
}
double area(){
return chang*kuan;
}
double zc(){
return 2*(chang+kuan);
}
}
public class a {
public static void main(String arge[]){
ZCMJ a=new ZCMJ(5,6);
"zhouchang="+());
"zhouchang="+());
}
}
运行结果：
zhouchang=
zhouchang=
【作业】设计一个圆类，成员变量包括半径r。类中有计算面积的方法；有构造函数，为圆的半径赋值。定义一个测试类，并输出圆的面积。【K】
abstract class Shape{
abstract protected double Area();
}
class circle extends Shape{
double radius;
circle(double r){
radius=r;
}
public double Area(){
return *radius*radius;
}
}
public class Circle_Test {
public static void main(String args[]){
circle c1=new circle(3);
}
}
Java笔记
4·4·3 static修饰符（P100）
·在类中声明一个变量或方法时，还可以指定它为实例成员或类成员。
·static修饰的成员叫做类成员，否则叫做实例成员。
1、实例变量
【没有static修饰的变量】
·不同对象的同名实例变量占用不同的内存空间。
·通过对象名来访问实例变量。
2、类变量
·同一类中的所有对象的类变量共享一个存储空间，一个对象对类变量的操作，会影响到同一类的其他对象。·可以使用类名引用类变量，也可以使用对象名引用类变量。
public class MethTest {
static int var1=100;
int var2=200;
public static void main(String arge[]){
MethTest obj1=new MethTest();
MethTest obj2=new MethTest();
++;
++;
++;
++;
++;
}
}
3、实例方法
·实例方法可以对当前对象的实例变量和类变量进行操作。
·实例方法必须由实例对象调用。
4、类方法
·类方法只能对类变量进行操作。
·类方法可以用类名调用，也可以用对象名调用，类方法不同将类实例化就可以直接调用。
如果类方法与调用它的程序处于同一个类中，则调用时类名也可以省略。
class StaticDemo{
static int x;
int y;
public static int getX(){
return x;
}
public static void setX(int newX){
x=newX;
}
public int getY(){
return y;
}
public void setY(int newY){
y=newY;
}
}
public class Test {
public static void main(String[] args){
"静态变量x="+());
StaticDemo a=new StaticDemo();
StaticDemo b=new StaticDemo();
(10);
(20);
(30);
(40);
"静态变量="+());
"静态变量="+());
}
}
运行结果：
静态变量x=0
静态变量=30
静态变量=40
Java笔记
所有的Java类都直接或间接的继承了Java。
说明：
·如果类sub是类super的子类，则类sub继承了超类super的变量和方法。
·子类sub中，包括两部分的内容：从超类super中继承下来的变量和方法，自己新增加的变量和方法。4·5·2子类的创建
1声明子类
在声明子类的同时，声明类的超类
[<修饰符>] class <子类名> extends <超类名>
{ 子类成员变量声明
子类成员方法声明 }
如：class Trash_Car extends Car
{ 子类体 }
子类的每个对象也是超类的对象。超类的对象不一定是子类的对象。
2子类如何继承超类（父类）中的成员变量
·继承原则：子类只继承超类中非private的成员变量
·隐藏原则(Hiding)：子类的成员变量和超类的成员变量同名时，超类的成员变量被隐藏。若想使用超类的成员变量用super.
class Person{
String name;
int age;
String address;
void setPerson(String name,int age,String address){
=name;
=address;
=age;
}
void print(){
"woshiperson");
}
}
class Student extends Person{
String department;
void setStudent(String name,int age,String address,String department){
=name;
=age;
=address;
=department;
}
void print(){
"woshistudent");
}
}
public class Person_ex {
public static void main(String arge[]) {
Person p=new Person();
("tom",21,"121");
Student s=new Student();
("john",22,"336","computer");
/*" "++" "+;
" "++" "+;*/
();
}
}
3. 子类继承超类的成员方法
继承原则：子类只继承超类中非private的成员方法
覆盖原则(Override)：子类的成员方法和超类的成员方法同名时，超类的成员方法被隐藏。
4、子类的构造函数
·子类不能继承父类的构造方法
·在调用子类的构造方法时，要先调用父类的构造方法
·如果子类想使用父类的构造方法，必须在子类的构造方法中使用super关键字来调用，且必须是子类构造方法中的第一条语句
·如果在子类中的构造方法中没有使用super调用父类的某个构造方法，则系统在执行子类的构造方法时会自动调用父类的默认的构造方法。（即无参的构造方法）
class Person {
String name;
int age;
String address;
Person(String name,int age,String address){
=name;
=address;
=age;
}
void print(){
"woshiperson");
}
}
class Student extends Person{
String department;
Student(String name,int age,String address,String department){
super(name,age,address);
=name;
=age;
=address;
=department;
}
void print(){
"woshistudent");
}
}
public class Person_ex {
public static void main(String arge[]) {
Person p=new Person("tom",21,"121");
/*Student s=new Student();
("john",22,"336","computer");*/
" "++" "+;
/*" "++" "+;
();*/
}
}
运行结果：
tom 21 121
4.5.3 几种对象运算符
1. null
null 表示类的空对象，即没有创建类的任何实例
2. this
使用this表示正在使用该方法的对象
this引用的使用方法如下：
1. 访问本类的成员：
this.<变量名>
this.<方法名>
2. 调用本类的构造函数
this([参数列表])
3. super
Super有三种情况可以使用：
(1) 用来访问父类中被隐藏的成员变量。
(2) 用来访问父类中被覆盖的方法；
(3) 用来调用父类中的构造方法；
如果子类和超类有同名的成员变量或方法，则：
super.<成员变量名>
super.<成员方法名>
表示引用超类的成员（如无super则表示引用子类中的同名成员）
用super调用超类的构造方法
super([参数列表])
4.5.4 最终类和抽象类
1. 最终类和最终方法
用final修饰的类为最终类。最终类不能有子类。
用final修饰的方法为最终方法。最终方法不会在子类中被覆盖（即子类中不能有和此方法同名的方法）。
2、抽象方法，不能用static、final修饰。抽象类，不能用final修饰。
抽象方法用关键字abstract修饰。只允许声明，不设方法体。抽象方法是必须被子类覆盖的方法。如：abstract void write() ；
用abstract修饰的类叫做抽象类，抽象类不能用new运算符创建对象。抽象类中可以有抽象方法也可以没有。
一旦类中包括了抽象方法就必须声明为abstract
若超类是抽象类，子类必须实现超类中所有抽象方法
Java笔记
第四章全是重点！
4·6类的多态
什么是多态性：多态性是指同一个名字的若干个方法，有不同的实现（即方法体中的代码不一样）。
当我们用一个方法名调用方法时，执行的是这些方法的不同版本中的一种。
多态性通过方法重载和方法覆盖来实现
4·6·1方法的重载
什么是重载（overloading）：在一个类中，定义多个名称相同，但参数个数或参数类型不同的方法，java根据参数的个数或参数类型，调用相对应的方法。
重载的关键是参数的类型或个数必须不同。
void a (int x);
int a (int x)【不是重载函数】
void a(int x,int y);
void a (int x); 【是】
void a(float x ,int y);
void a (int x,float y); 【是】
·重载的关键是参数的类型或个数必须不同。
4·6·2覆盖：
什么是覆盖（overriding）：是指在子类中，定义名称、参数个数与类型均与父类相同的方法，以重写父类中的方法的功能。
4·7 接口
在Java中，一个类只能有一个超类。但Java提供了接口用于实现多重继承，一个类可以有一个超类和多个接口。4·7·1接口的声明
接口由常量和抽象方法组成（P114）
[修饰符] interface <接口名>
{接口体}
修饰符：可以是public或默认访问控制。
接口体中的变量隐含为public final和static，它们必须被赋初值。
接口体中的方法隐含为public、abstract。都是抽象方法。必须在类中实现。
【类实现接口】
4·7·2接口的实现
一个类通过使用关键字implements实现一个或者多个接口。
class <类名> implements <接口名1>，<接口名2> 。。
当一个类实现了一个接口，它必须实现接口中所有的方法，这些方法都要被声明为public。
注意：方法的名字、返回类型、参数个数及类型必须与接口中方法一致。
4·8·1 JAVA的类和包
JAVA常用的包有：
语言包
实用包
抽象窗口工具包
文本包
输入输出流的包
Applet应用程序
网络功能
语言包：
提供了Java最基础的类，只有包不需要导入就能使用
Object
数据类型类
String和StringBuffer
Math
System，Runtime
Class
ClassLoader
错误和异常处理类
实用包
包提供了实现各种实用功能的类，如日期类、集合类等。
日期类包括Date、Calendar和GregorianCalendar类
集合类包括多种集合接口：Collection（无序集合）、Set（不重复集合）、List（有序不重复集合）和Enumeration （枚举）。
数据结构有关的类：Linklist（链表）、Vector（向量）、Stack（栈）、Hashtable（散列表）和Treeset（数）。第四章复习资料：
1.类的声明：
类首：【修饰符】class 类名 extends 父类名 implements 接口名
类主体：
变量
方法
2.对象的创建和使用
Student类
Students s = new Student();
s．变量名
s．方法名(参数列表)
3.构造方法（为对象进行初始化的）
特点：
1.类名相同
2.无返回值，没有void
为每一个类提供一个默认的无参的构造函数Student(){}
4.实体：当用一个类创建一个对象时，类中的成员变量被分配内存空间，这些内存空间被称作该对象的实体，而对象中存放着引用，以确保实体由该对象操作使用。
7.对象的生命周期
8.访问权限
1.类： public 默认，
如果在一个源文件中，声明了若干个类，则只能有一个类的权限是public，且这个类的名字和文件名字相同，一般main 方法在这个类中。
2.变量和方法：四种。
修饰符（8句话）
不同对象的同名实例变量占用不同的内存空间。
通过对象名来访问实例变量
同一类中的所有对象的类变量共享一个存储空间。
可以使用类名和对象名访问类变量。
实例方法可以对实例变量和类变量进行操作。
实例方法必须由对象调用。
类方法只能对类变量进行操作
类方法可以用类名和对象名调用
10.类的继承
1.子类和超类
2.子类继承超类的变量（两个原则）
3.子类继承超类的方法
4子类的构造方法（使用super）
this super对象运算符
12.最终类最终方法（final）
13.抽象类抽象方法（abstract）
抽象方法特点：（1）无方法体（2）必须被子类覆盖
抽象类特点：
（1）抽象类不能用new运算符创建对象。
（2）抽象类中可以有抽象方法也可以没有。
（3）一旦类中包括了抽象方法就必须声明为abstract
（4）若超类是抽象类，子类必须实现超类中所有抽象方法
抽象类不能被abstract和final同时修饰
抽象方法不能被abstract、static、final同时修饰
14.类的多态性
1.方法重载：一个类中，方法名称相同，参数个数和参数类型不同
2.方法覆盖：父类与子类定义方法名称、返回类型、参数个数、参数类型、均相同的方法
15.接口
1.接口内容：常量（默认为public、static、final）和抽象方法（public、abstract）
2.接口定义修饰符 interface 接口名
3.接口实现 class 类名 implements 接口名
4.特点：当一个类实现了一个接口，它必须实现接口中所有的方法，这些方法都要被声明为public。注意：方法的名字、返回类型、参数个数及类型必须与接口中方法一致。
16.包
1.声明包;package 包名
2.引用包：import 包名
3.包是有等级的，包中可以有包。
4.java常用的包有：
语言包
实用包
抽象窗口工具包
文本包
输入输出流的文件包
Applet应用程序
网络功能
Java笔记
第五章·Java的图形用户界面
5.1.1 java applet的编辑和运行
一、 java程序的分类
Java application 程序——是一个独立的完整的程序，只需解释器来解释运行。这类程序在被执行的过程中，程序员必须为程序指定开始被执行的起始点，这种起始点被称为程序入口，Java应用程序主要以main() 方法作为程序入口。
Java applet 程序——是嵌入到html网页中的非独立程序，不能独立运行，必须依靠web浏览器内部包含的java解释器来解释运行。
二、 java applet程序编辑
java applet程序的运行是依靠Web浏览器来实现的，所以其编辑分为两部分。
（1）与java application程序相同，即使用一个文本编辑软件对java applet 程序进行编辑。
（2 ）编写一个html文件。
EG：编写小应用程序，完成输出“这是我的第一个java applet 程序！”
第一步：在编辑软件中编写源程序，注意保存的文件名和保存的路径。
第二步：依靠浏览器解释执行java applet程序，应该有相应的html文件。注意保存的文件名和路径。
html源代码
import .*;
import .*;
public class HtmlText extends Applet {
public void paint(Graphics a){
("cldmx", 100, 100);
}
}
小应用程序编写时要求：
1.结构：
公共类的类名必须与文件名同名。
公共类必须是的子类
程序中无main( )方法
文件的
codebase, code (必须), name（可选）, width/height (必须) ,hspace/vspace(可选), Align（可选）, Param(可选), ALT ,archive
三 java applet程序的运行
1.使用eclipse集成环境
2.使用jdk调试
(1) 在DOS窗口下输入编辑命令
javac
(2) 在DOS下输入appletviewer ,