Java 面向对象编程

Java 面向对象编程

第一章 面向对象编程

• 面向对象是Java最重要的特性。Java是彻底的、纯粹的面向对象语言，在java中一切都是对象

1.1 面向对象简介

面向对象的编程思想：按照真实世界客观事务的自然规律进行分析，客观世界中存在什么样的实体，构建的软件系统就存在什么样的实体。

面向对象编程（object oriented programming,OOP）,作为面向对象的计算机语言——Java,具有定义类和创键对象等面向对象能力

1.2 面向对象的三个基本特性

面向对象的三个基本特性:封装性，继承性，多态性

1. 2.1 封装性

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点：

• 良好的封装性能够减少耦合
• 类内部的结构可以自由修改
• 可以对成员变量进行更精准的控制
• 隐藏信息，实现细节

代码示例：

//实现Java封装的步骤:
// 1.修改属性的可见性来限制对属性的访问（一般限制为private）
public class Person{
private String name;
private int age;
}
上面代码中，将name和age属性设置为私有，只能本类访问。自他类都访问不了
//2 对每个属性值提供对外的公共方法访问，也是创键一对赋值取值方法，用于对私有属性的访问
public class Person2{
	private String name;
	private int age;
	
	public int getAge(){
	return age;
	}
	public  String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public void setName(String name){
	this.name =name;
	}
}
//采用this关键字是为了解决实例变量（private String name)和局部变量（SetName(String name)中的name变量）之间发生的同名的冲突
// this 指向该类的成员变量

1.2.2 继承性

• 继承是Java面向对象编程技术的一块基石，因为它允许创键等级层次的类
• 继承就是子类继承父类的特征和行为，使得子类对象（示例）具有父类对象的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

类的继承格式：

calss 父类{
	方法体；    
}
class 子类 extends 父类{
}

实例说明：

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}
public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        //super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
        super(myName, myid); 
    } 
}

需要注意的是 Java 不支持多继承，但支持多重继承。

继承的特性：

• 子类拥有父类非private的属性、方法
• 子类可以拥有自己的方式实现父类的方法
• Java的继承就是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类
• 提高了类之间的耦合性， 继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差

继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

代码示例：

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

代码示例：

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

1.2.3 多态性

• 多态是同一个行为具有多个不同表现形式或形态的能力。

• 多态就是同一个接口，使用不同的实例而执行不同操作。

多态的优点：

1. 消除类型之间的耦合
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化行

多态生存的三个必要条件:

1. 继承
2. 重写
3. 父类引用指向子类对象

多态的实现方式

方式一：重写：

这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)

方式二：接口

• \1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
• \2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。

方式三：抽象类和抽象方法

1.3 类

1.3.1 类的声明

Java语言中有一个类的实现包括类声明和类体

[public] [abstract|final] class classname [extends superclassname] [implements interfaceNameList]{
    //类体
}
class:声明类的关键字;classname:自定义的类名;public abstract final 为修饰符
    abstract和final不能同时使用
	

1.3.2 成员变量

声明类体中成员变量语法格式：

class classnamne{
    [public|protected|private] [static] [final] type variablename;
}
参数说明：
    public、protected和private修饰符用于封装成员变量
    static修饰符用于声明静态变量，所以静态变量也称为“类变量”
    final修饰符用于声明变量，该变量不能被修改

1.3.3 成员方法

声明类体中成员方法语法格式如下：

class className{
    [public|protected|private] [static][final|abstract] [native] [synchronized] type methodName([paramList])[throws exceptionList]{
        //方法体
    }
}
参数说明;
    type:方法返回值数据类型;
	methodName:方法名;
	public、protected和private修饰符用于封装方法
     static:修饰符用于声明静态方法
   	natice:nativ修饰方法称为本地方法；
        synchronized修饰的方法是同步的，当多线程方式同步方法时，只能串行地执行

public class Animal{
	//动物年龄
	int age = 1;
	//动物性别
	public boolean sex =false;
	//动物体重
	private double weight =0.0;
	public void eat(){
	//方法体
	return;
	}
	int run(){
		//方法体
		return 10;
	}
	protected int getMaxNumber(int number1,int number2) {
		//方法体
		if(number1>number2) {
			return number1;
		}
		return number2;
	}
}

1.4 包

1.4.1 包作用

• Java中为了防止类、接口、枚举和注释等命名冲突引用了包（package)概念，包本质上是命名空间（namespace)
• 在包中可以定义一组相关的类型（类，接口，枚举，和注释）,并为他们提供访问保护和命名空间管理

1.4.2 包定义

Java中使用package定义包，package语句应该放在源文件的第一行，在每一个源文件中只能有一个包定义语句，并且package使用所有类型

1.4.3 包引入

• 使用import语句实现引入包，import语句应该仅次于package之后

语法格式：

import package1[.package2...].(类型名|*)

• 当前源文件与要使用的类型（类，接口，枚举和注释）在同一个包中，可以不用引入包

1.4.4 常用包

1. java.lang

   java.lang 包中提供了Java语言的核心，如Object、class、String,…

2. java.id

   提供多种输入/输出流，如，Writae,OutputStream,Reader

3. java.net

   包含网络相关操作的类，ruURL，Socket和ServerSocket

4. Java .util包

   包含一些实用工具类和接口，如集合，日期和日历等

5. java.text

   提供文本处理，日期格式化和数字格式化等相关类及接口

6. java.awt 和java.swing

   提供Java图形用户界面开发所需要的各种类和接口

1.5 方法重载

定义：同一个类中的多个方法可以有相同的方法名称，但是有不同的参数列表，这就称为方法重载（method overloading)

• 方法重载overload
• 方法重载中参数列表不同的含义是参数的个数不同或者参数类型不同，返回类型不能用来区分方法重载

代码示例

package oopdemo;
class MethodOverloading{
	void receive(int i) {
		System.out.println("接收一个int参数");
		System.out.println("i="+i);
	}
	void receive(int x,int y ) {
		System.out.println("接收两个int参数");
		System.out.printf("x=%d,y=%d\r",x,y);
	}
	int receive(double x,double y) {
		System.out.println("接收一个double参数");
		System.out.printf("x=%f,y=%f\r",x,y);
		return 0;
	}
}
public class overloadDemo {
		public static void main(String[] args) {
			MethodOverloading mo = new MethodOverloading();
			//调用void receive(int i )
			mo.receive(9);
			//调用void receive(int x,int y)
			mo.receive(2,6);
			//调用void receive(double x,double y)
			mo.receive(7.0,7.0);
		}
	}

输出结果

接收一个int参数
i=9
接收两个int参数
x=2,y=6
接收一个double参数
x=7.000000,y=7.000000

• 调用那个方法是由参数列表决定的，如果参数类型不一致则会报错
• 参数列表不同：个体不同、顺序不同、类型不同
• 仅仅参数变量名称不用是不可以的
• 跟成员方法一样，构造方法也可以重载
• 声明为final的方法不能被重载
• 声明为static的方法不能被重载，但是能够被在此声明

方法重载的规则：

• 方法名称必须相同
• 参数列表必须不同
• 方法的返回类型可以相同也可以不相同。
• 仅仅返回类型不同不足以称为方法的重载。

方法重载的实现：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错，这叫做重载分辨。

1.6 封装性与访问控制

• Java面向对象的封装性是通过对成员变量和方法进行访问控制实现的

• 访问控制的等级分为：私有、默认、保护、公有

  关键字	控制等级	同一个类	同一个包	不同包的子类	不同包非子类
  private	私有	YES
  	默认	YES	YES
  protected	保护	YES	YES	YES
  public	共有	YES	YES	YES	YES

1.6.1 私有级别

• 私有级别的关键字是private,私有级别的成员变量和方法只能在其所在类的内部自由使用，在其他的类中不允许直接访问
• 私有级别的访问限制性最高

代码示例：

//同一个类调用成功
package eclipseDeBug;

public class privateDemo {
		private int x;
		public privateDemo() {
			x = 100;
		}
		private void printx() {
			System.out.println("ValueOf x is"+x);
		}
	public static void main(String[] args) {
//		 TODO Auto-generated method stub
		privateDemo P = new privateDemo();
		P.printx();
	}

}
//调用失败
package eclipseDeBug;

public class helloWrod {
	public static void main(String[] args) {
		privateDemo P = new privateDemo(); //能初始化
//		P.printx(); 不能调用private修饰的方法
	}
}

1.6.2 默认级别

• 默认级别没有关键字，也就是没有访问修饰符
• 默认级别的成员变量和方法可以在其所在类内部和同一个包的其它类中被直接访问
• 在不同包的类中则不允许直接访问

package eclipseDeBug;
public class dfClass {
		int x;
		public dfClass() {
			x = 100;
		}
		void printx() {
			System.out.println("Value of x is" + x);
		}
	public static void main(String[] args) {
		dfClass p = new dfClass();//在同一个包中能够访问
		p.printx();
	}
	
}

package oopdemo; //不同包

import eclipseDeBug.dfClass;

public class helloWord {
	public static void main(String[] args) {
		dfClass p = new dfClass(); //能初始化，但是不能调用方法，因为类是公共的
//		p.print()
	}
}

1.6.3 保护级别

• 保护级别的关键子protected
• 保护级别在同一包中完全与默认访问级别一样，但是不同包中子类能够继承父类中的protected变量和方法
• 保护级别就是保护某个子类的子类都能继承该类的变量和方法

代码示例：

package eclipseDeBug;

public class protectedClass {
	protected int x;
	public protectedClass() {
		x = 100;
	}
	protected void printx() {
		System.out.println("Value Of x "+"\t"+x);
	}
}
//在同一个包内
package eclipseDeBug;

public class helloWrod {
	public static void main(String[] args) {
		protectedClass p = new protectedClass();
		p.printx();
	}
}
//在不同包中调用
package oopdemo;

import eclipseDeBug.dfClass;
import eclipseDeBug.protectedClass;

public class helloWord {
	public static void main(String[] args) {
	protectedClass p = new protectedClass();
//	p.printx(); 不能调用该方法
	}
}
//继承保护类
package oopdemo;

import eclipseDeBug.dfClass;
import eclipseDeBug.protectedClass;

public class helloWord extends protectedClass{
	void display() {
		printx(); //该方法从父类继承
		int y = 10;
		System.out.print(y); //该实例变量是从父类
	}
	public static void main(String[] args) {
	helloWord p = new helloWord();
	p.printx();
	p.display();
	
	}
}
输出结果：
Value Of x 	100
Value Of x 	100
10

提示：

• 访问成员有两种方式：
  1. 调用：即通过类或对象调用它的成员
  2. 继承：子类继承父类的成员变量和方法
• 公有访问级别在任何情况下两种方式都可以
• 默认访问级别在同一包中两种访问方式都可以，不能在包之外访问
• 保护访问级别在同一包中与默认访问级别一样，两种访问方式都可以，但是在不同包之外只能继承访问
• 私有访问级别只能在本类中通过调用方法访问，不能继承访问

1.6.4 公有级别

• 公有级别的关键字是public，公有级别的成员变量和方法可以在任何场合被直接访问

1.7 静态方法和静态变量

1.7.1 静态变量

static变量也称作静态变量，静态变量和非静态变量的区别是：

静态变量：静态变量被类中所有的对象所共享，它将变量值存储在一个公共的内存地址，因为地址公共，所以如果某个对象修改了静态变量的值，那么同一个类的所有对象都会受到影响。

非静态变量：非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

1.7.2 静态方法

静态变量和方法可以在不创建对象的情况下进行访问。

静态方法与实例方法的区别：

静态方法：静态方法会随着类的定义而被分配和装载入内存中。静态方法可以调用静态方法以及访问静态数据域，但静态方法不能调用实例方法或者访问实例数据域。

实例方法：只有在类的对象创建时在对象的内存中才有这个方法的代码段。实例方法可以调用实例方法和静态方法，以及访问实例数据域或者静态数据域。

代码示例：

package eclipseDeBug;

public class staticClass {
	//实例变量账户金额
	double amount = 0.0;
	//实例变量账户名
	String owner;
	//静态变量利率
	static double interestRate = 0.068;
	//静态方法
	public static double interestBy(double amt) {
		//静态方法可以访问静态变量和其他静态方法
		return interestRate * amt;
	}
	//实例方法
	public String messageWith(double amt) {
		//实例方法可以访问实例变量、实例方法、静态变量和静态方法；
		double interset = staticClass.interestBy(amt);
		StringBuilder sb = new StringBuilder();
		//拼接字符串
		sb.append(owner).append("的利息").append(interset);
		//返回字符串
		return sb.toString();
	}
	public static void main(String[] args) {
		//访问静态变量
		System.out.println(staticClass.interestRate);
		//访问静态方法
		System.out.println(staticClass.interestBy(100000));
		//初始化
		staticClass sc = new staticClass();
		sc.interestRate = 10000000;
		sc.owner = "susu";
		//访问实例方法
		System.out.println(sc.messageWith(1000));
		//通过实例访问静态变量
		System.out.println(sc.interestRate);
	}
}
/*
0.068
6800.000000000001
susu的利息1.0E10
1.0E7
*/

静态代码块：

package eclipseDeBug;

public class staticClass {
	//实例变量账户金额
	double amount = 0.0;
	//实例变量账户名
	String owner;
	//静态变量利率
	static double interestRate = 0.068;
	//静态方法
	public static double interestBy(double amt) {
		//静态方法可以访问静态变量和其他静态方法
		return interestRate * amt;
	}
	static {
		//静态代码块，可以在声明的时候初始化
		System.out.println("静态代码块被调用=============");
		interestRate = 0.7989;
	}
	//实例方法
	public String messageWith(double amt) {
		//实例方法可以访问实例变量、实例方法、静态变量和静态方法；
		double interset = staticClass.interestBy(amt);
		StringBuilder sb = new StringBuilder();
		//拼接字符串
		sb.append(owner).append("的利息").append(interset);
		//返回字符串
		return sb.toString();
	}
	public static void main(String[] args) {
		//访问静态变量
		System.out.println(staticClass.interestRate);
		//访问静态方法
		System.out.println(staticClass.interestBy(100000));
		//初始化
		staticClass sc = new staticClass();
		sc.interestRate = 10000000;
		sc.owner = "susu";
		//访问实例方法
		System.out.println(sc.messageWith(1000));
		//通过实例访问静态变量
		System.out.println(sc.interestRate);
	}
}
/*输出结果
静态代码块被调用=============
0.7989
79890.0
susu的利息1.0E10
1.0E7
*/

第二章 对象

• 类实例化可生成对象，实例方法就是对象方法，实例变量就是对象属性

2.1 创键对象

1. 声明

   声明对象与声明普通变量没有区别

   type objectName;
   

   type是引用类型，即类、接口和数组

2. 实例化

   实例化过程分为两个阶段：为对象分配内存空间和初始化对象，首先使用new运算符为对象分配内存空间，然后再调用构造方法初始化对象

   String name;
   name = new String("hello word");
   

2.2 空对象

• 一个引用变量没有通过new分配内存，这个对象就是空对象
• Java使用关键字null表示空对象

String name =null;
name = "hello word"

引用变量默认值是null，当试图调用一个空对象的实例变量或实例方法时，会抛出空指针异常NullPointException

String name = null;
// 输出null字符串
System.out.println(name);
//调用length()方法
int len = name.length();

产生空对象有两种可能性：

1. 没有实例化
2. 空对象是别人传递过来的

2.3 构造方法

Java构造方法的特点：

1. 构造方法必须与类名相同
2. 构造方法没有任何返回值
3. 构造方法只能与new运算符结合使用

public class Rectangle{
    //矩形宽度
    int width;
    //矩形高度
    int height;
    //矩形面积
    int area;
    //构造方法
    public Rectangle(int w,int h){
       width = w;
        height = h;
        area = getArea(w,h)
    }
}

2.3.1 默认构造方法

• Java虚拟机为没有构造方法的类提供一个无参数的默认构造方法

public  方法名字与类同名(){}

2.3.2 构造方法重载

• 在一个类中可以有多个构造方法，具有相同的名字（与类名相同）,参数列表不同，所以他们是重载的关系

  package eclipseDeBug;
  
  import java.util.Date;
  
  public class Person {
  	private String name;
  	private int age;
  	private Date birthdate;
  	public Person(String n,int a,Date d) {
  		this.name  = n;
  		this.age = a;
  		this.birthdate = d;
  	}
  	public Person(String n,int a) {
  		this.name = n;
  		this.age = a;
  	}
  	public Person(String n) {
  		this.name = n;
  	}
  	public String getInfo() {
  		StringBuilder sb = new StringBuilder();
  		sb.append("名字:").append(name).append('\n');
  		sb.append("年龄:").append(age).append('\n');
  		sb.append("出生日期:").append(birthdate).append('\n');
  		return sb.toString();
  	}
  }
  

2.4 构造方法

• this关键字指向对象本身
• 调用实例变量
• 调用实例方法
• 调用其他构造方法

package eclipseDeBug;

public class thisClass {
	private String name;
	private int age;
	private String city;
	//调用三个参数构造方法
	public thisClass(String name,int age,String city){
		this.name = name;
		this.age = age;
		this.city = city;
		System.out.println(this.toString());
	}
	public thisClass(String name,int age) {
		//调用三个参数构造方法
		this(name,age,null);
	}
	public thisClass(String name,String city) {
		//调用三个参数的构造方法
		this(name,30,city);
	}
	public thisClass(String name){
		//调用thisClass(String name,int age)构造方法
		this(name,null);
	}
	public String toString() {
		return "thisClass [name="+name +",age"+age+","+city+"]";
	}
	public static void main(String[] args) {
		thisClass tc = new thisClass("Java",18,"江西");
		System.out.println(tc.toString());
	}
}

第三章 继承与多态

3.1 Java中的继承

• 在类的声明中没有使用extends 关键字指明其父类，则默认父类Object类
• java.lang.Object是Java的根类
• 单继承：一般情况下一个子类只能继承一个父类
• 多重继承：特殊情况下一个子类可以有多个不同的父类，可以通过接口的方式实现
• 面向对象分析与设计（OOAD）时，会用到UWL图

3.2 调用父类构造方法

当子类实例化时，不仅需要初始化子类成员变量，也需要初始化父类成员变量，初始化父类成员变量需要调用父类构造方法，子类使用super关键字调用父类构造方法。

父类：

package eclipseDeBug;

public class fatherClass {
	private String name;
	private int age;
	private String city;
	//三个参数构造方法
	public fatherClass(String name,int age,String city) {
		this.name = name;
		this.age = age;
		this.city = city;
        System.out.println("这是父类");
	}
	public fatherClass(String name,int age) {
		//调用3个参数构造方法
		this(name,age,null);
	}
	
}

子类：

package eclipseDeBug;

public class helloWrod extends fatherClass{
	private String school;
	public helloWrod(){
		
	}
	public helloWrod(String name,int age,String city,String school) {
		super(name, age,city);
		this.school = school;
		System.out.println("这是子类");
	}
	public static void main(String[] args) {
		helloWrod hw = new helloWrod("su",16,"jiangxi","asf");
		
		hw.school = "jiangxi";
		System.out.println(hw.school);
		
	}
}

输出结果：

这是父类
这是子类
jiangxi

• 在父类中添加，默认构造方法，子类会隐式地调用父类的默认构造方法
• 在子类构造方法中添加super语句,显示地调用父类构造方法，super语句必须是在第一条语句
• 在子类构造方法添加this语句，显示地调用了当前对象的其他构造方法，this语句必须是第一条语句

3.3 成员变量隐藏和方法覆盖

3.3.1 成员变量隐藏

• 子类成员变量与父类一样，会隐蔽父类中的成员变量，称为“成员变量隐藏”

代码示例：

package eclipseDeBug;

public class parentClass {
	int x = 10;
	public static void main(String[] args) {
		subClass sc = new subClass();
		sc.print();
	}
}
class subClass extends parentClass{
	int x = 20;
	public void print() {
		//访问子类对象x成员变量
		System.out.println("x="+x);
		//访问父类x成员变量
		System.out.println("super="+super.x);
	}
}

输出结果：

x=20
super=10

3.3.2 方法覆盖

• 子类覆盖：如果子类方法完全与父类方法相同，即相同的方法名、相同的参数列表和相同的惭悔之，只是方法体不同

package eclipseDeBug;

public class parentClass {
	int x;
	protected void setValue() {
		x = 10;
		System.out.println("这是父类");
	}
	public static void main(String[] args) {
		subClass sc = new subClass();
		sc.setValue();
		sc.print();
		System.out.print(sc.x);
	}
}
class subClass extends parentClass{
	//屏蔽父类x成员变量
	int x ;
	@Override
	protected void setValue() {
		// TODO Auto-generated method stub
		//访问子类对象x的成员
		x = 20;
		//调用父类setValue()方法
		super.setValue();
		System.out.println("这是子类");
	}
	public void print() {
		//访问子类对象X的成员变量
		System.out.println("x="+x);
		//访问父类x的成员变量
		System.out.println("super.x="+super.x);
	}
}

方法覆盖遵循的原则：

1. 覆盖后的方法不能比原方法有更严格的访问控制（可以相同）
2. 覆盖后的方法不能比原方法产生更多的异常

3.4 多态

发生多态的三个前提条件：

1. 继承，多发生在子类和父类之间
2. 覆盖，子类覆盖了父类的方法
3. 声明的变量类型是父类类型

第四章 抽象类与接口

4.1 抽象类

4.1.1 抽象类的概念

• 在Java中有具体抽象方法的类称为“抽象列”

4.1.2 抽象类声明和实现

• java中抽象类和抽象方法的修饰符是abstract

声明抽象代码示例：

public abstract class Figure{
    //绘制几何图形方法
    public abstract void onDraw();
}

• 如果一个方法声明为抽象的，那么这个类也必须声明为抽象的
• 抽象类不能被实例化，只有具体类才能被实例化

4.2 接口

• 比抽象类更加抽象的是接口，在接口中所有的方法都是抽象的

4.2.1 接口声明和实现

• Java中接口声明使用的关键字是interface

代码示例：

public interface Figure{
    //接口静态成员变量
    String name  = “几何图型”; //省略public static final
    //绘制几何图形方法
    void onDraw(); //省略public
}

• 声明接口使用interface关键字，interface前面的修饰符是public或省略
• 某个类实现接口时，要在声明时使用implements关键字，多个接口用“，”分隔

public class ellipses implements Figure{
    //绘制几何图形方法
    public void onDraw(){
        System.out.println("绘制椭圆形");
    }
}

第五章 枚举类

5.1 枚举类的声明

• Java使用enum关键字声明枚举类

//语法格式
【public】enum 枚举名{
    枚举常量列表

• enum前面的修饰符[public]表示public或省略
• 枚举名是该枚举类的名称，遵循Java命名规范

代码示例：

package eclipseDeBug;

public enum WeekDay2 {
	//枚举常量列表
	MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY
}

package eclipseDeBug;

public class WeekDay {
	public static void main(String[] args) {
		//day 工作日变量
		WeekDay2 day = WeekDay2.FRIDAY;
		System.out.println(day);
		switch(day) {
		case MONDAY:
			System.out.println("周一");
			break;
		case TUESDAY:
			System.out.println("周二");
			break;
		case WEDNESDAY:
			System.out.println("周三");
			break;
		case THURSDAY:
			System.out.println("周四");
			break;
		default:
			System.out.println("周五");
		}
	}
}

5.2 枚举类型中的成员变量和成员方法

• 枚举类可以向类一样包含成员变量和成员方法
• 成员变量可以是实例变量也可以是静态变量，成员方法可以是实例方法也可以是静态方法，但不能是抽象方法

代码示例：

package eclipseDeBug;

public enum WeekDay2 {
	//枚举常量列表
	MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY;
	//实例变量
	private String name;
	private int index;
	//静态方法
	private static int staticVar = 100;
	//覆盖父类的toString()方法
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		StringBuilder sb = new StringBuilder();
		sb.append(name);
		sb.append('-');
		sb.append(index);
		return sb.toString();
	}
	//实例方法
	public String getInfo() {
		//调用父类中toString()方法;
		return super.toString();
	}
	//静态方法
	public static int getStaticVar() {
		return staticVar;
	}
}

package eclipseDeBug;

public class WeekDay {
	public static void main(String[] args) {
		//day 工作日变量
		WeekDay2 day = WeekDay2.FRIDAY;
		System.out.println(day);
		//打印day默认调用枚举toString方法
		System.out.println(day.getInfo());
		//调用枚举静态方法
		System.out.println(WeekDay2.getStaticVar());
		
	}
}

输出结果
null-0
FRIDAY
100

5.3 枚举类构造方法

package eclipseDeBug;

public enum WeekDay2 {
	//枚举常量列表
	MONDAY("周一",0),TUESDAY("周二",1),WEDNESDAY("周三",2),THURSDAY("周四",3),FRIDAY("周五",4);
	//实例变量
	private String name;
	private int index;
	//静态方法
	private static int staticVar = 100;
	private WeekDay2(String name,int index) {
		this.name = name;
		this.index = index;
	}
	//覆盖父类的toString()方法
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		StringBuilder sb = new StringBuilder();
		sb.append(name);
		sb.append('-');
		sb.append(index);
		return sb.toString();
	}
	//实例方法
	public String getInfo() {
		//调用父类中toString()方法;
		return super.toString();
	}
	//静态方法
	public static int getStaticVar() {
		return staticVar;
	}
}

package eclipseDeBug;

public class WeekDay {
	public static void main(String[] args) {
		//day 工作日变量
		WeekDay2 day = WeekDay2.FRIDAY;
		System.out.println(day);
		//打印day默认调用枚举toString方法
		System.out.println(day.getInfo());
		//调用枚举静态方法
		System.out.println(WeekDay2.getStaticVar());
		
	}
}

周五-4
FRIDAY
100

5.4 枚举常用方法

• 所有枚举类都继承java.lang.Enum类
• int ordinal():返回枚举常量的顺寻，这个顺寻根据枚举常量声明的顺寻而定，从零开始
• 枚举类型[] Value是（）:静态方法，返回一个包含全部枚举常量的数组
• 枚举类型ValuesOf（String str）:静态方法，str是对应枚举常量对应的字符串，返回一个包含枚举类型的实例

代码示例

package eclipseDeBug;

public class enum2 {
	public enum WeekDay{
		//枚举常量列表
		MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY
	}
	public static void main(String[] args) {
		//返回一个包含全部枚举常量的数组
		WeekDay[] allvalues = WeekDay.values();
		//遍历枚举常量数值
		for(WeekDay word:allvalues) {
			System.out.printf("%d-%s\n",word.ordinal(),word);
		}
		//创键Weekday对象
		WeekDay day1 = WeekDay.FRIDAY;
		WeekDay day2 = WeekDay.valueOf("FRIDAY");
		System.out.println(day1 == WeekDay.FRIDAY);
		System.out.println(day1.equals(WeekDay.FRIDAY));
		System.out.println(day1 == day2);
	}
}

提示：

• == ：比较两个引用是否指向同一个对象
• equals:是比较对象的内容是否相同

---

版权声明：本文为CSDN博主「义无反顾xk」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
blic static void main(String[] args) {
//day 工作日变量
WeekDay2 day = WeekDay2.FRIDAY;
System.out.println(day);
//打印day默认调用枚举toString方法
System.out.println(day.getInfo());
//调用枚举静态方法
System.out.println(WeekDay2.getStaticVar());

}

}

~~~java
周五-4
FRIDAY
100

5.4 枚举常用方法

• 所有枚举类都继承java.lang.Enum类
• int ordinal():返回枚举常量的顺寻，这个顺寻根据枚举常量声明的顺寻而定，从零开始
• 枚举类型[] Value是（）:静态方法，返回一个包含全部枚举常量的数组
• 枚举类型ValuesOf（String str）:静态方法，str是对应枚举常量对应的字符串，返回一个包含枚举类型的实例

代码示例

package eclipseDeBug;

public class enum2 {
	public enum WeekDay{
		//枚举常量列表
		MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY
	}
	public static void main(String[] args) {
		//返回一个包含全部枚举常量的数组
		WeekDay[] allvalues = WeekDay.values();
		//遍历枚举常量数值
		for(WeekDay word:allvalues) {
			System.out.printf("%d-%s\n",word.ordinal(),word);
		}
		//创键Weekday对象
		WeekDay day1 = WeekDay.FRIDAY;
		WeekDay day2 = WeekDay.valueOf("FRIDAY");
		System.out.println(day1 == WeekDay.FRIDAY);
		System.out.println(day1.equals(WeekDay.FRIDAY));
		System.out.println(day1 == day2);
	}
}

提示：

• == ：比较两个引用是否指向同一个对象
• equals:是比较对象的内容是否相同

---

版权声明：本文为CSDN博主「义无反顾xk」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xkfanhua/article/details/80561673