java总结

          Java   4—5月 总  结

一 知 识 要 点

***********************************************

1：数据类型

 

2：String类

 

3：数组与队列

 

4：类与对象

 

5：继承

 

6：图形界面

 

7：重绘

 

8：五子棋

 

 

 

二 展开知识要点

**********************************************

--------   数据类型

Java 中的数据类型可分为基本类型、类类型（严格地讲数组类型也属于类类型）

基本类型可分为byte(字节型)、int（整型）、short(短整型)、long(长整型)、char(字符型)、float(浮点型)、double(双精度)、boolean(布尔型)

与之相对应的类类型为Byte、Integer、Short、Long、Char、Float、Double

注意：1：java中的布尔型boolean的变量仅有2个，即ture和false。ture和false不能转换成任何数值表示，java中的ture不表示1，false不是0，不参与算数运算

      2：对于类中定义的原子类型变量，若未给出初

值，那么他们将有默认值，但在方法内定义的局部变量应当对其赋值。

 

 

---------   String类

1：对象创建

方法一：String类和其他类一样，可以用new操作符，并调用该类的构造函数创建这种类型的对象。

程序截取示例：

public String （char  value[ ]) {

char a[ ]={‘s’‘o’‘n’‘g’};        //字符数组

String str=new String(a);        // 字符串str的内容是song

 

}

方法二：采用字符串常量初始化一个String引用类如：String st=“abc”；

        等价于  char date[ ]={‘a’‘b’,‘c’}; String str=new String(data);

2: String类常用方法

** 求得字符串的长度的方法

程序截取示例：

public int length( ){

String str=“Java”;

System.out.println(str.length( ));

} 

注意：不要将该方法与获取数组长度的方法混淆了，获取串的长度是采用了方法length( )，而获取数组长度是通过实例变量length，即：数组名.length

 

**  对字符串内容进行比较

程序截取示例：

public int compareTo(String  another String ){

String  str s[ ]={ “Computer”“China”“world”“U.S.A” }；

s[1].compareTo s[2]

 

}

 

**  将参数对象连接到调用对象的后面

程序截取示例：

public String contact(String str){

String  s1=“Hello”， String  s2=“Java”，s3;

s3= s1. contact(s2);

System.out.println(s3);

 

}

 

**   将String对象中的所有oldChar字符替换为 newChar，并返回替换后的新串

程序截取示例：

public String replace(char oldChar, (char newChar ){

String path=“my duty”;

System.out.println(path.replace(“me”));

}

*值传递与引用传递的区别

1：值传递传的是值，而引用传递传的是地址

2: 值传递所传数值之间相互独立，而引用传递“牵一发而动全身”

例：int i=10; 

int y=i;

y++;

（此时i仍为10）

Student  s1;

s1.setName(“张三”)；

Student  s2;

s2=s1;

S2.setName(“李四”)；

（此时s1将变为李四）

 

---------    数组与队列

（由于一维数组有二维数组相似，此处只对一维数组进行总结）

数组：

1:数组变量的声明

数据类型  数组名=new数据类型[ length]

例：int[] Array=new int[ length];

注意：数组一旦创建好，大小就不能再改变

2：数组的初始化

方法一：根据下标依次赋值

int[ ] a=new int[2];

int[0]=10;

int[1]=20;

方法二：在列表中直接赋值

int[ ] a={10，20}；

 

2：向方法传递数组

程序截取示例：

{

int [ ] data 1={1,2,3};

System.out.println(“data1:”+sum(data1));

}

//sum the element in a array

static int sum(int [ ] a) {

int sum=0;

for(int  i=0;i<a.length; i++)

sum=sum+a[i];

return sum;

}

队列：

（因为数组的大小在创建的时候已经固定了，想要改变数组的大小已经不可能了。这时候使用自定义队列来实现。队列可以无限制的扩展存储空间，但是扩展的空间必须小于内存的存储范围。）

1：自定义队列的实现

   使用数组来实现队列.

1.定义一个接口,用来定义实现自定义队列的所有方法（后文将对接口进行解释）

2.定义一个类实现该接口，并且重写接口中的所有方法；定义一个原始数组 array

 定义一个统计队列的总长属性 count

2：队列接口中常涉及到的方法（用泛型进行优化）

    定义一个添加元素的方法

    public void add(E element);

//定义一个在指定索引位置的地方添加一个元素

public void add(int index,E element);

//定义一个删除指定索引位置的元素方法

public Object remove(int index);

//定义一个删除指定元素的方法

public Object remove(E element);

//定义一个修改指定索引位置的元素值

public boolean update(int index);

//定义一个修改指定元素的值

public boolean update(E oldElement, E newElement);

//定义一个返回队列总元素个数

public int count ();

//定义一个获取指定索引位置的元素方法

public E ele (int index);

}

 

---------    类与对象

1：定义：简单的说，类就是对象的抽象，而对象即类的实例

2：类的定义格式：class className

3：对象的创建  

    类名  对象名=new  类名（）；

4：通过对象名调用方法

    对象名.方法名（）；

 注意：类名的首字母要大写 ；类名要有一定的实际意义；对象名不可与关键字或特殊符号相同；

 

---------    继承(关键字  extends)

**   子类可以从父类继承所有的方法和域，也可以在增加新的域和方法。子类还可以进行方法的重写。

程序截取示例：（进行比较）

Class Person {             

Person(Stringname){       

this.name=name; }                                                    

public String tostring( ){ 

return ("Name:"+name); }                       

                                             

class Student{

Student(Stringname){

 super(name) ;}     

public String tostring( ){

return(super.toStrng"Name:"+name+"\n"+"college:"+college);

  }

} 

由比较可知：1：构造函数绝不能继承。 构造函数可以调用超类中的构造函数，调用形式和方法调用差不多，但方法之前要有关键字super。                                        

 2：重写父类方法时可以访问父类的该方法，但要用关键字super。                                         

**   方法重载

 方法重载的要求    

一个函数的函数名与另一个函数的函数名相同，但是它们的参数列表中的参数类型，个数，顺序至少有一项不同

**     继承所涉及的“自动转型”

原则：有父类对象的地方就可以用子类对象替换父类对象。（因为子类对象可以访问父类的所有方法）

     转型法法1：父类名  父类对象=子类对象；                                              

     如：Person  any person= student;

          System.out,println(any person.toString( ));                                                

     (注意 ：实际上调用了Student类的toString( )方法)

 转型方法2：  父类名   父类对象=new  父类名（）；                                                      

              父类对象.方法名（）；

              父类对象=new 子类名（）；

              父类对象.方法名（）；

如：（父类为SuperClass，子类为SubClass，父类有print( )方法，子类重写了该方法）

     SuperClass  s=new SuperClass（）； 

     s.print( )；

     s=new SubClass（）； 

     s.print( )；

    (  实际上是父类调用了父类的print( )方法，子类调用了子类的print( )方 法 ）

**    抽象类(关键字   abstract  )

      抽象类要定义派生类的公共属性，但它自身不能创建对象

      定义格式：

       abstract  class-name

**     接口（关键字 interface）

      注意：1：可以把接口视为纯抽象类，接口只能有抽象方法和常量

            2：接口方法不能使静态方法

            3：接口中只能有public的方法

       程序截取示例：

        Intetface   Living {

        public  void computeNeighbor(   ) ;

         Count  getCount( );

 

          }

---------    图形界面

**        用于监听或响应按钮压下事件的步骤总结如下：

      1：用 new JButton("some  lable")创建一个按钮

      2：用add在JFrame的内容窗体中添加按钮

      3：创建一个监听器，并给该监听器绑定一个类  

   的对象，该类将继承另一个类以实现实现指定方法 

      4:给按钮添加监听器

 程序截取示例：

        public class DrawFrame extends JFrame {

      public static void main(String[] args) {

  //创建桌面窗口

          DrawFrame df = new DrawFrame();

   df.initial();

 

     // 设置颜色按钮

javax.swing.JButton buttoncolor = new javax.swing.JButton("颜色");            

     // 给按钮添加监听器

           buttoncolor.addActionListener(al) 

         

        //创建监听器

         ml = new DrawListener(g);

   

this.addMouseListener(ml);

        }

  //  DrawListener  类 继承 另一类以实现指定方法

 

Public classDrawListener extends java.awt.event.MouseAdapter {

（省略了程序）

}

---------     重绘

 重绘利用于画板和五子棋中，主要利用了类的封装特性。

public class Graph 

//封装属性

private int x1,y1,x2,y2;

private Color color;

private String type;

}

 重绘即重写了超类的paint方法，用队列来保存数据

public void paint(java.awt.Graphics g) {

super.paint(g);

if (ml != null) {

LiveImplements<Graph> list = ml.getList();

// 获得队列元素

for (int i = 0; i < list.count(); i++) {

Graph gra = list.ele(i);

// 开始判断之前画的图形类型是直线还是其他的图形

if (gra.getType().equals("Line")) {

// 设置颜色

g.setColor(gra.getColor());  

// 重绘图形了

g.drawLine(gra.getX1(), gra.getY1(),    

              gra.getX2(),

gra.getY2());

---------     五子棋

五子棋是在画板的基础上发展的，也利用了重绘和接口的知识。此处不做详细说明

<!--EndFragment-->