天空是蓝色的

做好软件为中国 #gcc -c helloworld.c -o helloworld.o //编译目标文件 #gcc helloworld.o -o helloworld //编译成可执行exe #helloworld //运行exe
数据加载中……
第五章:使用对象和类编写程序面向对象编程的概念声明和创建对象

第五章:使用对象和类编写程序面向对象编程的概念声明和创建对象
构造方法
修饰符 (public, private 和 static)
实例变量、实例方法、类变量和类方法
变量的作用域
关键字this的用法
类中的对象关系分析(UML)
实例学习
Java应用程序接口
String类

类的含义
1.类:类封装了一类对象的状态和方法。类是用来定义对象的模板。对象是类的实例。
2.类的实现包括两部分:类声明和类体。基本格式为:
     修饰符  class 类名
     {
     类体的内容
       }

3.类声明举例:
public   class People { }
class 人类{}
类名、变量、方法都可以是汉字。
4.修饰类的修饰符:
      public : 类、方法或数据域在任何包中的任何程序中可见。
     默认修饰符: 类、方法或数据域在所在的包中可见。
     final:  终极类不能扩展。终极方法不能在子类中修改。终极数据域是常量。
     abstract:  抽象类必须被扩展。抽象方法必须在具体的子类中被实现。抽象方法不能有实例。

5.类体:由两部分构成——变量的定义和方法的定义
6.类中的变量叫做实例变量和类变量(static)。
7.类中的方法叫做实例方法和类方法(static)。
8.在方法中可以对成员变量和方法体中自己定义的局部变量进行操作。实例方法可以直接对类变量和实例变量操作,而类方法可以直接使用类变量,也可以通过对象访问实例变量

1.  class Student2. {
3.        float height,weight;
5.        String 姓名;
5.        static int age=20;
6.  height=175f;
7.  }

如何编写一个类类声明
类体
变量的声明
方法的声明

类声明类名:
修饰符:
默认修饰符
public
final
abstract

变量的定义修饰符
默认
public
private
protected
static
final
类型
变量名


方法的定义修饰符
返回值
方法名
参数
方法体

实例编写:圆类Circle
分析:
有那些属性、状态是描述一个圆类的。
有那些行为跟这些数据发生联系,或是本类应该具有的行为。

class Circle
{
  double radius = 1.0;
  double findArea()
  {
    return radius*radius*3.14159;
  }
}

 

类和对象对象
1.对象(object):代表现实世界中可以明确标识的任何事物。
2.对象有自己的状态和行为。
3.对象的状态是属性或域以及它们的当前值构成的集合。
4.对象的行为是方法的集合。
5.类是定义一个对象的数据和方法的模板。对象是类的实例。可以从一个类中创建许多实例。创建一个实例被称为实例化。对象和实例两个词通常可以互换。

对象声明
1.类名 对象名;  
Circle myCircle;
2.变量声明的同时系统创建了这个变量并为它分配了适当的内存空间。也就是说变量的声明和创建是同时进行的。
3.但是对象变量的声明和创建是两个分离的步骤。对象的声明只是简单地把对象和类联系起来,使对象成为该类地一个实例。

创建对象
1.对象名=new  类名();  
  myCircle=new Circle();
2.也可以利用下面的语法把声明和实例化用一条语句完成:
   类名 对象名=new 类名();
   Circle myCircle=new Circle();

简单数据类型和对象类型的区别
1.每个变量名代表一个存储值的内存地址。
2.一个简单类型变量存放简单类型的值。
3.一个对象类型变量存放指向对象在内存中存储位置的引用。

简单数据类型和对象类型的区别简单数据类型和对象类型的复制
1.将一个对象复制到另一个对象变量不是复制对象;
2.它仅仅是将一个对象变量的引用值赋给另一个对象变量。


简单数据类型和对象类型的复制垃圾回收
1.Java运行系统监测垃圾并自动收回垃圾对象占用的空间。这个过程叫做垃圾回收(garbage collection)。
2.如果认为一个对象已经不再需要,可以将该对象的引用变量明确赋值为null,Java虚拟机将自动收回那些不被任何变量引用的对象所占的空间。
3.例:Circle c1,c2;               
       c1=new Circle();               
        c2=new Circle();               
        c1=null;
        c1=c2; 

对象访问访问对象的成员变量:
   objectName.data        myCircle.radius访问对象的成员方法:
   objectName.method         myCircle.findArea()


例:使用对象
说明如何创建对象、访问成员变量、使用成员方法

构造方法
Circle(double r)

  radius = r;
}
Circle()
{
  radius = 1.0;
}
myCircle = new Circle(5.0);

例:构造函数的使用
用构造函数创建对象

给方法传递对象引用传递
值传递

传递简单类型变量与传递对象的区别传递简单类型变量就是将其值传递给形参。改变方法内部的参数不会影响方法外部的变量值。
传递对象意味着将对象的引用传递给形参。方法内局部对象的任何变化都会影响作为参数传递的原对象。

方法参数方法不能修改基本类型的参数。
方法可以改变对象参数的状态。
方法不能使一个对象参数指向一个新的对象。

包package包(package)主要用来组织标准类和我们自己编写的程序,它会影响你为类、变量和方法所使用的名字。
Java中所有的标准类都包含在包中。
包是有层次关系的,包中还可以有包。
包嵌套的层次可以用来保证包的名称的唯一性。
包名的唯一性非常重要,因为Internet上的其他程序有可能使用的你的包。Java语言的设计者建议以Internet的域名的倒序作为包的前缀。
Java要求包名与文件系统的目录结构一一对应。一个包实际上是包含类字节码的目录 

在包中添加类
Java中每个类都属于一个包。类在编译时添加到包中。要把一个包放在指定包中,只需在程序的最前端加上下列语句,前面只能有注释和空格。      
    package packagename;
当源程序没有指定包的时候,默认这样的程序都是放在默认包中,或称无名包。

使用包(编译一个包,访问一个包)
要在程序中使用包(跟当前程序不同包)中的类,在程序顶端加入语句import:例如:import java.io.BufferedReader;
如果要使用同一个包中的多个类,用星号(*)表明使用包中所有类。
    import java.io.*;


可见性修饰符public:用它定义的类、方法和数据,所有程序都可以访问。
private:用它定义的方法或数据,只能由定义该方法的类访问,而其他类不能访问
protected:方法或数据域在所属包中可见,或者在任何包中该类的子类中可见。
默认修饰符:即类、方法和数据前没有修饰符的时候,那么默认是类、方法和数据可以被同一个包中的任何类访问。


注意:带有可见性修饰符的变量是类的成员,而不是方法的局部变量。在方法内部使用可见性修饰符会引起编译错误。
大多数情况下,构造方法应该是public的。但是,如果想防止用户创建类的实例,可以使用私有的构造方法。 

访问器方法
对象不能直接访问私有域,但是用户常常需要检索和修改数据域。为了能够访问数据域,可以为私有数据域添加读取方法(getter)和设置方法(setter),这些方法称为访问器方法。

访问器方法getter:
public returnType getPropertyName()
如果returnType是boolean型,则按照习惯getter方法应按如下定义:
public boolean isPropertyName()
setter方法:
public void setPropertyName(dataType propertyValue)


类变量和实例变量区别class Vb

{int i=0;
        static int j=0
        ;        Vb()       
{                i=i+1;                j=j+1;        }
        public static void main(String[] args)
        {        Vb v=new Vb();System.out.println("j is"+j)
        ;        System.out.println("i is"+v.i);Vb b=new Vb();
        System.out.println("j is"+j);        System.out.println("i is"+b.i);                }}


实例方法和类方法实例方法和实例变量都是在实例创建后被分配内存类方法和类变量都是在类第一次使用时被分配内存
例:ClassName cname=new ClassName();

使用条件声明类变量:如果想让一个类中的所有实例共享数据,请用类变量。
声明类方法:不使用实例变量的方法可以定义为类方法。

实例变量和类变量类方法:在一个类里面——直接使用类变量,实例名.实例变量。在别的类里面——类名.类变量,实例名.实例变量。
实例方法:在一个类里面——直接使用类变量,实例变量。在别的类里面——类名.类变量,实例名.实例变量。
无论是什么方法,无论在类的里面还是外面,都可以实例名.变量名。但是建议类变量和类方法还是直接用类名引用比较好,提高可读性。

变量的作用域变量的作用域(scope of variable):即变量可以被使用的范围。
实例变量和类变量用来描述对象的属性。类中所有的方法都可以访问这些变量,所以这两种变量称作全局变量global variable。
在方法中说明的变量叫做局部变量。局部变量的作用域从它的声明开始延续到包含它的块尾。局部变量必须先说明后使用。

变量的作用域不要在块内声明一个变量,而在块外使用。
例:for(int i=0;i<10;i++){}  int j=i;
在一个方法互不嵌套的块中,可以用同一个名字多次声明局部变量,但是不能在嵌套的块中声明多次。

在一个方法互不嵌套的块中,可以用同一个名字多次声明局部变量public void correctMethod
{
        int x=1;
        int y=1;
        for(int i=1;i<10;i++)
        {
                x+=i;
        }
        for(int i=1;i<10;i++)
        {
                y+=i;
        }
}


不能在嵌套的块中声明多次public void incorrectMethod
{
        int x=1;
        int y=1;
        for(int i=1;i<10;i++)
        {
                int x=0;
                x+=i;
        }
}


关键字this
this指的是对象本身。
用关键字this可以访问隐藏的实例变量。
也可以在构造方法中使用关键字this。this()语句必须出现在构造方法中任何其他方法之前。

用关键字this访问隐藏的实例变量class Foo
{
int i=5;
void setI(int i)
{
this.i=i;    
}
}

在构造方法中使用关键字thispublic class Circle
{
private double radius;
public Circle(double radius)
{
this.radius=radius;
}
public Circle()
{
this(1.0);

}

聚集
聚集是一种特殊的关联形式, 表示两个类的关联形式。
  聚集模拟这样的关系:具有(has-a)、包含(part-of)、拥有(own)、雇佣(employed-by),等等。

类抽象
   类抽象意味着将类的实现和使用分离。 类的创建者提供了类的描述,让使用者明白如何使用类,而使用者不需要知道类是如何实现的。实现的细节经过封装,对用户隐藏起来。

类的设计
  1. 设计、标识系统的类
2. 描述每个类的属性和方法
3. 建立类之间的关系
4. 创建类

例5.6抵押贷款
The following is a test program that uses the classes Name, Address, Borrower, and Mortgage

Java API 和核心类java.lang包含Java的核心类(如Object、String、System、Math、Number、Character、Boolean、Byte、Short、Integer、Long、Float和Double等)。每个Java程序隐含地导入该包。java.awt
包含图形类。java.applet
包含支持applet的类

Java API 和核心类
java.io
包含用于输入输出数据流和文件的类
java.util
包含许多工具,如日期等
java.net
包含支持网络通讯的类

String类构造一个字符串字符串比较
字符串连接
子串
字符串长度
获取字符串的单个字符

构造一个字符串String s = new String("Welcome to Java!“);
String s = new String();
String s= "Welcome to Java!“※※String类一旦创建,无法改变!

字符串比较if(str1= =str2) System.out.println(“str1 和 str2 是同一个对象”);
    else System.out.println(“str1 和 str2 是不同的对象”);
运算符”==”只检查string1和string2是否指向同一个对象,它不能辨别两个不同的对象是否包含相同的内容。因此,不能用“==”号检测两个串变量是否具有相同的内容。


字符串比较equals()方法可以用于对象内容相等的比较。
  s1.equals(s2); 如果二者内容相同,返回true,否则返回false。
 compareTo()方法也可以用来比较两个字符串。s1.compareTo(s2);或"a".compareTo(“b”);
  如果s1等于s2,方法返回0;如果按字典顺序s1小于s2,方法返回一个小于0的值;如果按字典顺序s1大于s2,方法返回一个大于0的值。


字符串连接concat方法:
String s3=s1.concat(s2);
+号:
String myString=s+”and”+”HTML!”;

子串public String substring(int  beginindex,int  endindex)
public String substring(int  beginindex)
例:
String s1 = "Welcome to Java";
String s2 = s1.substring(0,10) + "HTML";
String s2 = s1.substring(0) + "HTML";


获取字符串长度
s.length()方法:返回字符串的长度。s.charAt(index)方法可以获取字符串s中指定的字符,其中index的范围是0到s.length()-1。
message = "Welcome";
message.length();


获取字符串单个字符Do not use message[0]Use message.charAt(index)Index starts from 0

例5.8验证回文串检查一个字符串是否为回文串:是否从前读它和从后读它都是一样的。
主要程序代码:   
    int low = 0;
    int up = s.length() - 1;
    while (low < up)
    {
      if (s.charAt(low) != s.charAt(up))
        return false;
      low++;
      up--;
    }
    return true;


StringBuffer 类
StringBuffer类比String类更灵活,可以在字符串缓冲区中添加、插入或追加新内容。

StringBuffer 构造方法public StringBuffer()
  构造一个没有字符的字符串缓冲区,初始容量为16个字符
  例:StringBuffer strb=new StringBuffer();
public StringBuffer(int length) 
构造一个没有字符的字符串缓冲区,初始容量由length定。
例:StringBuffer strb=new StringBuffer(10);
public StringBuffer(String string)
  给参数string构造一个字符串缓冲区,初始容量为string长度再加16个字符。
  StringBuffer strb=new StringBuffer(“java”);


在StringBuffer类中追加和插入新内容11个重载方法append可以在字符串缓冲区末尾追加新内容。例:StringBuffer strBuf=new StringBuffer();
      strBuf.append(“Welcome”);
10个重载方法insert可以在字符串缓冲区中插入新内容。strBuf.insert(11,”HTML and “);
每个缓冲区都有一个容量,如果超过它的容量,缓冲区会自动加大以存放新加的字符。
例:StringBuffer strBuf = new StringBuffer();
   strBuf.append("Welcome");
   strBuf.append(\' \');
   strBuf.append("to");
   strBuf.append(\' Java\');
   strBuf.append(“ and HTMl!");

StringBuffer的常用方法
public int capacity()
这个方法返回字符串缓冲区的当前容量。
public synchronized StringBuffer reverse()
这个方法反转字符串缓冲区中的字符串
public int length()
这个方法返回缓冲区中字符的个数
public synchronized setLength(int newLength)
这个方法设置字符串缓冲区的长度。
public synchronized charAt(int index)
这个方法返回字符串缓冲区中指定位置的字符
public synchronized void secasearAt(int index,char ch)
这个方法将字符串缓冲区中指定位置的字符设置为ch。


StringTokenizer类java.util.StringTokenizer类:使用这个类可以将一个串分成小片(令牌),以便提取和处理其中的信息。
例:“I am learning Java now.”
使用时需要在文件头部加上:
   import  java.util.StringTokenizer;


StringTokenizer 类的构造方法构造StringTokenizer对象时,可以指定一套定界符号,定界符把串分成称为令牌(token)的小片。


StringTokenizer 类的构造方法StringTokenizer(String s, String delim)
  根据指定的定界符为字符串s构造一个StringTokenizer对象,令牌中不包括定界符。
  StringTokenizer st=new StringTokenizer("aabccbddb","b");
StringTokenizer(String s)
根据默认的定界符为字符串s构造一StringTokenizer对象,默认定界符为空格、制表符、换行符和回车。令牌中不包含定界符。
StringTokenizer st=new StringTokenizer
("aa cc dd");

StringTokenizer 类的常用方法public int countTokens()
这个方法返回StringTokenizer中剩余的令牌数。
boolean hasMoreTokens()
如果字符串中还有令牌则这个方法返回true.
String nextToken()
这个方法返回串中下一个令牌。
String nextToken(String delim)
重置delim的定界符后,这个方法返回串中下一个令牌

posted on 2005-12-12 11:07 bluesky 阅读(1877) 评论(0)  编辑  收藏 所属分类: 工作总结


只有注册用户登录后才能发表评论。


网站导航: