Java类与对象导学

爱被打了一巴掌 2022-03-02 17:38 284阅读 0赞

1.  面向对象方法的特征

**抽象**：从同类型对象中抽象出共同的属性和行为形成类；  
忽略与当前目标无关的内容。

**封装**：把数据和处理数据的方法封装到一个类里；  
利用抽象数据类型将数据和基于数据的操作封装在一起。

**继承**：在已有类的基础上产生新的类；  
新的类获得已有类（称为超类，基类或父类）的属性和行为；称新类为已有类的字类（派生类）。在继承过程中，字类继承了超类的特性，包括方法和实例变量；字类也可以修改继承的方法或增加新的方法。有助于解决代码的可重用性问题，使程序结构清晰，降低了编码和维护的工作量。

**多态**：在继承的环境下父类和子类都能响应同名的消息，但响应消息的具体实现办法不同。字类覆盖超类方法。

1.  类与对象基础  
    类与对象的关系：类是一类对象的描述；对象是类的具体实现。

**类的声明：**

[public] [abstarct|final]  class  类名称  [extends 父类名称]  [implements 接口名称列表] {
    	数据成员声明及初始化；
    	方法声明及方法体；
    	}

Clock钟表类：

public class Clock {
    	//变量成员
    	int hour；
    	int minute；
    	int second；
    	//方法成员
    	public void setTime(int newH ,int newM , int newS) {
    		hour=newH;
    		minute=nerM;
    		second=news;
    	}
    	public void showTime() {
    		System.out.println(hour+":“+minute+”:"+second);
    	}
    }

**对象的创建**  
对象应用声明：  
语法：  
类名，引用变量名；  
Clock是已经声明的类名，声明引用变量aclock，用于存储该类对象的引用：  
`Clock aclock；`  
创建对象：  
语法：`new <类名>()` new在内存中为Clock类型的对象分配内存空间；返回对象的引用；  
例如：

aclock = new Clock();

引用变量可以赋以空值 `aclock = null;`

**数据成员**  
表示对象的状态；可以使任意的数据类型；

[public | protected | privete] 
    [static] [final] [ transient ] [volatile] 
    // public / protected / private 为访问控制符
    // static指明这是一个静态成员变量
    // fina 指明变量的值不能被修改
    // transient指明变量不许要序列化
    // volatile指明变量是一个共享变量。

**实例变量**：没有static修饰的变量（数据成员）属于各个对象。  
存储所有实例都需要的属性，不同实例的属性值可能不同；  
可通过下面的表达式访问实例属性的值：<实例名>.<实例变量名>

public class Circle {
    	int raidus;
    }
    public class ShapeTester {
    	public static void main(String[] args) {
    		Circle x =  new Circle();
    		System.out.println(x);
    		System.out.println("raidus = " + x.raidus);
    	} 
    }
    /*运行结果如：
    Circle@6bc7c054
    raidus = 0

int数据类型默认为0；所有的类默认的toString() 方法返回：

getClass().getName() + "@" +Integer.toHexString(hashCode())

**类变量**：（静态变量）  
用static修饰；在整个类中只有一个值；类初始化时就被赋值。  
适用情况：类中所有对象都相同的属性；经常需要共享数据；系统中用到的一些常量。  
引用格式：`<类名|实例名>.<类变量名>`。

方法成员  
语法形式：

[public|protected|private]
    [static][final|abstract][native][synchroized]
    返回类型 方法名([参数列表]) [ throw excptionList]
    {
    	方法体
    }

**实例方法**：属于每个对象  
表示特定对象的行为；声明时前面不加static。  
实例方法调用：给对象发消息，使用对象的某个行为/功能：调用对象的某个方法。

实例方法调用格式
    <对象名>.<方法名>([参数列表])
    <对象名>为消息的接收者。

参数传递：  
值传递：参数类型为基本数据类型时；  
引用传递：参数类型为对象类型或数组时；

import java.awt.Rectangle;
    
    public class Circle02 {
    	static double PI = 3.14159;
    	int radius;
    	public double circumference() {
    		return 2 * PI *radius;
    	}
    	public void enlarge(int factor) {
    		radius = radius * factor;
    	}
    	public boolean fitsInside(Rectangle r) {
    		return (2 * radius < r.width) && (2 * radius < r.height);
    	}
    }
    import java.awt.Rectangle;
    
    public class InsideTester01 {
    	public static void main(String[] args) {
    		Circle02 c1 = new Circle02();
    		c1.radius = 8;
    		Circle02 c2 = new Circle02();
    		c2.radius = 15;
    		Rectangle r = new Rectangle();
    		r.width = 10;
    		r.height = 29;
    		System.out.println("Circle1 fits inside Rectangle:" + c1.fitsInside(r));
    		System.out.println("Circle2 fits instde Rectangle:" + c2.fitsInside(r));
    	}
    }

**类方法**（静态方法）  
声明前需加static修饰；不能被声明为抽象；可类名直接调用，也可实例调用。

//转换，此功能只需要摄氏度和公式中的常量值，不依赖具体类实例的属性值，因此可以声明为类方法。
    public class Converter {
    	public static int centigradeToFahrenheit (int cent) {
    		return (cent * 9 / 5 + 32);
    	}
    }
    //调用
    Converter.centigredeToFahrenheit(23)

可变长参数，加 …实际上是数组。

String ...s     //表示 String[] s.
    
    static double maxArea(Circle c, Rectangle...varRec){
    	Rectangle[] rec = varRec;
    	for (Rectangle r : rec) {
    	}
    }

对于具有可变长参数的方法，传递给可变长参数的实际参数可以是零个对象到多个对象。

**包**：一组类的集合；  
将相关的源代码文件组织在一起；  
类名的空间管理，利用包来划分名字空间可以避免类名冲突；  
提供包一级的封装及存取权限。

包的命名：  
每个包名必须是“独一无二的”；  
Java中包名使用小写字母表示；  
命名方式建议：将机构的Internet域名反序，作为包名的前导；用下划线处理不可用标识符。  
编译单元：一个Java源文件  
一个Java源文件由3部分组成：所属包的声明（省略，则属于默认包）；Import （引入）包的声明，用于导入外部的类；类的接口和声明。  
一个编译单元只能有一个public类，该类名与文件名相同，编译单元中的其他类往往是public类的辅助类，经过编译，每个类都会产生一个class文件。

包的声明：  
命名的包（Named Packages) `package Mypackage;`  
默认包（未命名的包）：不含有包声明的编译单元是默认包的一部分。

包与目录：包名就是文件夹名，及目录名；目录名不一定是包名。  
引入包：  
为了使用其他包中所提供的类，需要使用import语句引入所需要的类。  
Java编译器为所有程序自动引入包`java.lang`。  
静态引入：  
单一引入是引入某一指定的静态成员，例如`import static java.lang.Math.PI.`;  
全体引入是指引入类中的所有的静态成员，例如`import static java.lang.Math.*.`;  
例如 ：

import staitc java.lang.Math.PI;

引入后使用其成员时不用加类名。

类的访问权限控制  
类成员在不同范围是否可以被访问：

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>修饰</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>同一类</td> 
   <td>private</td> 
  </tr> 
  <tr> 
   <td>同一包中的子类</td> 
   <td>无修饰</td> 
  </tr> 
  <tr> 
   <td>同一包中的非子类</td> 
   <td>无修饰</td> 
  </tr> 
  <tr> 
   <td>不同包中的子类</td> 
   <td>protected</td> 
  </tr> 
  <tr> 
   <td>不同包中的非子类</td> 
   <td>pubic</td> 
  </tr> 
 </tbody> 
</table>

通过公有接口访问私有成员变量。  
get方法 ：取得属性变量的值；get方法以get开头，后面是实例变量的名字  
例如：`public int getRadius() {return radius;}`  
set方法：修改属性变量的值；set方法以set开头，后面是实例变量的名字  
例如：`public void setRadius(int r) {redius = r);}`  
this关键字：如果方法内的局部变量名与实例变量名相同，则方法体内访问实例变量时需要this关键字。  
例如：`public void setRadius(int radius) {this.radius = radius;}`

1.  对象初始化和回收  
    对象初始化：系统在生成对象时，会为对象分配内存空间，并且自动调用构造方法对实例变量进行初始化；  
    对象回收：对象不再使用时，系统会调用垃圾回收程序将其占用的内存回收。

构造方法：方法名与类名相同；不定义返回类型；通常被声明为公有的；可以由多个从参数；主要时完成对象的初始化工作；不能在程序中显式的调用，在生成一个对象时会自动调用该类的构造方法为新对象初始化；若是未显式声明构造方法，编译其隐含生成默认的构造方法。  
默认构造方法：没有参数，方法体为空；使用默认的构造方法初始化对象时，如果在类声明中没有给实例变量赋初值，则对象的属性值为零或空。

自定义构造方法和方法重载：  
在生成对象时，给构造方法传送初始值，为对象进行初始化；  
构造方法可以被重载：一个类中有两个及以上的同名方法，但参数表不同，这种情况就被称为方法重载。在方法调用时，可以通过参数列表的不同来辨别应调用哪一个方法。只要显示声明了构造方法，编译器就不再生成默认的构造方法。

//为BankAccount声明一个具有三个参数的构造方法
    public Bankccount（String initName ,int initAccountNumber, float initBalance){
    	ownerName = initName;
    	accountName = initAccountNumber;
    	balance = initBalance;
    }
    //假设一个新账号的初始余额可以为0，则可增加一个带有2个参数的构造方法
    public BankAccount(String initNumber, in initAccountNumber) {
    	ownerName = initName;
    	accountNumber = initAccountNumber;
    	balance = 0.0f;
    }
    //无参数构造方法——自定义默认的初始化方式
    public BankAccount () {
    	ownerName = "";
    	accountNumber = 999999;
    	balance = 0.0f;
    }

声明构造方法时使用this关键字：实现个构造方法之间的相互调用；避免写冗余的构造方法体；通常用参数个数比较少 的构造方法调用调用参数个数比较多的构造方法。

public BankAccount() {
    	this("", 99999,0.0f);
    }
    public BankAccount(Strnig initName, int initAccountNumber) {
    	this(initName, initAccountNumber ,0.0f);
    }
    public BankAccount(String initName, int initAccountNumber, float initBalance) {
    	owenerName = initName;
    	accontNumber = initAccountNumber
    	balance = initBalance;
    }

final变量的初始化：  
实例变量和类变量都可以被声明为final；  
final实例变量可以在类中定义时给出初始值，或者在每个构造方法结束之前完成初始化；  
final类变量必须在声明的同时初始化。

内存回收：  
无用对象：离开作用域的对象；无引用指向的对象。  
Java运行时系统通过垃圾收集其周期性地释放无用对象所使用的内存。  
Java运行时系统会在对象进行自动垃圾回收之前，自动调用对象的finalize()方法。  
垃圾收集器：自动扫描对象的动态内存区，对不再使用的对象做标记以进行垃圾回收；作为一个后台线程运行，通常在系统空闲异步的执行。

finalize() 方法
    //在类java.lang.Object中声明，因此Java中的每一个类都有该方法：
    `protected void finalize() throws throwable`
    用于释放资源；类可以覆盖（重写）finalize()方法。
    finalize()方法有可能在任何时机以任何次序执行。

1.  枚举类型  
    要定义一种新类型时，如果对象的可取值有一定范围，且可取值可一一列举。即可定义一个枚举类。

[public] enum 枚举类型名称
    	[implements 接口名称列表]
    {
    	枚举值；变量成员声明及初始化；方法声明及方法体；}

enum Score {
    	EXCELLENT,
    	QUALIFIED,
    	FAILED;
    };
    public class ScoreTester {
    	public static void main (String[] args) {
    		giveScore(Score.EXCELLENT);
    	}
    	public static void giveScore(Score s){
    		switch(s){
    			case EXCELLENT:
    				system.out.println("Excellent");
    				break;
    			case QUALIFIED:
    				System.out.println("QUALIFIED");
    				break;
    			case FAILED;
    				System.out.println("FAILED");
    				break;
    		}
    	}

枚举类特点：  
枚举类实际上时定义了一个类；  
所有枚举类型都隐含继承（扩展）自`java.lang.Enum`,因此所有枚举类型不能再继承其他任何类；  
枚举类型的类体中可以包括方法和变量；  
枚举类型的构造必须是包内私有或私有，定在枚举的开头的常量会被自动创建，不能显式的调用枚举类的构造方法。  
枚举类型的默认方法：  
静态的value() 方法用于获得枚举类型的枚举值的数组；  
toString方法返回枚举值的字符串描述；  
valudOf方法将以字符串形式表示的枚举值转化为枚举类型的对象；  
Ordinal 方法获得对象在枚举类型中的位置索引。

1.  应用实例

//BankAccount类
    public class BankAccount {
    	private String ownerName;
    	private int accountNumber;
    	private float balance;
    	public BankAccount() {
    		this("",0,0);
    	}
    	public BankAccount(String initName,int initAccNum, float initBal) {
    		ownerName = initName;
    		accountNumber = initAccNum;
    		balance = initBal;
    	}
    	public String getOwnerName() {return ownerName;}
    	public int getAccountNumber() {return accountNumber;}
    	public float getBalance() {return balance;}
    	public void setOwnerName(String newName) {
    		ownerName = newName;
    	}
    	public void setAccountNumber(int newNum) {
    		accountNumber = newNum;
    	}
    	public void setBalance(float newBalance) {
    		balance = newBalance;
    	}
    }
    
    //AccountTester测试类；
    public class AccountTester {
    	public static void main(String[] args) {
    		BankAccount anAccount;
    		anAccount = new BankAccount("lalala", 2324234,0);
    		anAccount.setBalance(anAccount.getBalance() + 100);
    		System.out.println("here is a accont:" + anAccount);
    		System.out.println("Account name : " + anAccount.getAccountNumber());
    		System.out.println("Account number:" + anAccount.getOwnerName());
    		System.out.println("Balance: $" + anAccount.getBalance());
    		
    	}
    }

**覆盖toString()方法**：  
toString() 方法：将对象的内容转换为字符串：

System.out.println(anAccount);
    System.out.println(anAccount.toString());

**toString()方法覆盖**  
如果需要特殊的转换功能，则需要自己覆盖toString()方法：  
必须被声明为：public  
返回类型为：String；  
方法的名称必须为：toString，且没有参数；  
在方法体中不要使用输出方法System.out.println()。

**DecimalFormat** 类  
DecimalFormat类在java.text包中；  
在toString()方法中使用DecimalFormat类的实例方法format对数据进行格式化。

类的声明  
类的对象的声明  
对象的构造  
对象的初始化和回收