Java 枚举类继承父类 java枚举继承接口

抽象类，接口，枚举

• 一，继承

• 1，继承

• 一个父类可以有多个子类，而一个类只能有一个直接父类。子类可以访问父类的成员变量和成员方法，同hi也可以修改或重写父类的方法。通过继承可以实现代码复用。

• 2，举例应用

• 创建一个父类person，再创建一个子类Student继承父类person（使用toString和equals方法实现某些功能）

• 二，抽象类

• 1，抽象类即提供一个模板，根据他的格式去创建和修改新的类。
• 2，抽象类的举例应用

• 定义一个形状抽象类，根据他创建一个圆形子类和长方形子类，将其中的抽象方法（求面积 求体积 两个子类所共有的）在子类中实现，以供子类使用。

• 三，接口

• 1，接口可以实现多继承
• 2，接口的举例应用

• 定义一个形状类接口，以圆形类和长方形类来实现接口，并将接口中的抽象方法实现以供使用

• 四，枚举

• 1，举例应用

• 定义一个表示一周七天的枚举，并在主方法中遍历枚举所有成员

• 2，利用foreach语句遍历输出各元素

一，继承

1，继承

一个父类可以有多个子类，而一个类只能有一个直接父类。子类可以访问父类的成员变量和成员方法，同hi也可以修改或重写父类的方法。通过继承可以实现代码复用。

2，举例应用

创建一个父类person，再创建一个子类Student继承父类person（使用toString和equals方法实现某些功能）

//创建一个父类
class Person{
	
	//声明变量
	private String name;
	private char sex;
	private int age;
	
	//构造有参数的方法
	public Person(String name,char sex,int age) {
		this.name=name;
		this.sex=sex;
		this.age=age;
	}
	
	//构造无参数的方法
	public Person() {
		
	}
	
	//重写toString方法返回字符串
	public String toString() {
		return name+","+sex+","+age;
	}
	
	//使用equals方法判断两个学生是否相等
	public boolean equals(Student student) {
		 if(this.name==student.getName() && sex==sex && age==age) {
			    return true;
		 }
	     else {
		       return false;
	     }
	}
	
	//用get方法获取变量
	public String getName() {
    	return name;
    }
	public String getSex() {
    	return name;
    }
	public String getAge() {
    	return name;
   }
}

//创建一个Student子类继承父类Person
class Student extends Person{
	
	//声明变量
	private long number;
	private int phi,eng,comp;
	
	//构造有参数的方法
	public Student(String name,char sex,int age,long number,int phi,int eng,int comp) {
		super(name, sex, age);
		this.number=number;
		this.phi=phi;
		this.eng=eng;
		this.comp=comp;
	}
	
	//构造无参方法
    public Student() {
		
	}
    
    //写成员方法求得平均分
    public double aver() {
		return (phi+eng+comp)/3;
	}
    //写成员方法求最大分
	public int max() {
		return phi>eng?(phi>comp?phi:comp):(eng>comp?eng:comp);
	}
	//写成员方法求最低分
	public int min() {
		return phi<eng?(phi<comp?phi:comp):(eng<comp?eng:comp);
	}
	
	//重写toString方法返回所需字符串 
	public String toString() {
		
		return "学号："+number+" "+"姓名："+getName()+" "+"性别:"+getSex()+" "+"年龄："+getAge()+" "+"平均分："+aver()+" "+"最高分："+max()+" "+"最低分:"+min();
	}
	
	//用equals方法判断两个学生是否相等
	public boolean equals(Student student) {
		if(getName() == student.getName() && getSex()==student.getSex() && getAge() == student.getAge() && number==number) {
			return true;
		}
		else {
			return false;
		}
	}
}

//主类
public class SSS {
	//主方法 程序入口
      public static void main(String[] args) {
    	//声明父类变量指向子类对象
		Person s1=new Student();
		Person s2=new Student();
		//判断两个学生是否相等
		System.out.println(s1.equals(s2));
	}
}

二，抽象类

1，抽象类即提供一个模板，根据他的格式去创建和修改新的类。

2，抽象类的举例应用

定义一个形状抽象类，根据他创建一个圆形子类和长方形子类，将其中的抽象方法（求面积 求体积 两个子类所共有的）在子类中实现，以供子类使用。

//定义一个形状抽象类
abstract class Shape{
	
	//声明变量name
	protected String name;
	
	//构造方法(抽象类中的一般方法)
	public Shape(String name) {
		this.name=name;
		System.out.print("名称："+name);
	}
	
	//将求面积的方法声明为抽象方法
	abstract public double getArea();
	
	//将求体积的方法声明为抽象方法
	abstract public double getLength();
}

//定义继承自Shape的圆形子类Circle
class Circle extends Shape{
	
	//声明最终变量并赋值
	private final double PI=3.14;
	
	//声明变量radius
	private double radius;
	
	//构造方法并调用父类的一般方法
	public Circle(String name,double radius) {
		super(name);
		this.radius=radius;
	}
	
	//实现抽象类中的getArea()方法
	public double getArea() {
		return PI*radius*radius;
	}
	
	//实现抽象类中的getLength()方法
	public double getLength() {
		return 2*PI*radius;
	}
}

//定义继承自Shape的一个长方形子类Rectangle
class Rectangle extends Shape{
	
	//声明变量
	private double length;
	private double wide;
	
	//构造方法并调用父类中的一般方法
	public Rectangle(String name,double length,double wide) {
		super(name);
		this.length=length;
		this.wide=wide;
	}
	
	//实现抽象类中的getArea()方法
	public double getArea() {
		return length*wide;
	}
	
	//实现抽象类中的getLength()方法
	public double getLength() {
		return 2*(length+wide);
	}
}

public class A {
	//main方法为主方法，程序的入口
     public static void main(String[] args) {
    	 //声明父类对象，指向子类对象
		Shape s1=new Circle("圆",10.2);
	     //利用对象调用方法求面积和周长并输出
		System.out.print("; 面积： "+s1.getArea());
		System.out.println("; 周长： "+s1.getLength());
		//声明父类对象，指向子类对象
		Shape s2=new Rectangle("长方形",6.5,10.3);
		//利用对象调用方法求面积和周长并输出
		System.out.print("; 面积："+s2.getArea());
		System.out.println("; 周长："+s2.getLength());
	}
}

三，接口

1，接口可以实现多继承

2，接口的举例应用

定义一个形状类接口，以圆形类和长方形类来实现接口，并将接口中的抽象方法实现以供使用

//定义接口
interface IShape{
	
	//声明静态成员变量
	static final double PI=3.14;
	
	//声明抽象方法
	double getArea();
	double getLength();
}

//以ICirle来实现ISape接口
class ICircle implements IShape{
	
	//声明变量
	private double radius;
	
	//构造方法
	public ICircle(double radius) {
		this.radius=radius;
	}
	
	//实现接口中的getArea()方法
	public double getArea() {
		return PI*radius*radius;
	}
	
	//实现接口中的getLength()方法
	public double getLength() {
		return 2*PI*radius;
	}
}

//以IRectangle 来实现ISape接口
class IRectangle implements IShape{
	
	//声明变量
	private double length;
	private double wide;
	
	//构造方法
	public IRectangle(double length,double wide) {
		this.length=length;
		this.wide=wide;
	}
	
	//实现接口中的getArea()方法
	public double getArea() {
		return length*wide;
	}
	
	//实现接口中的getLength()方法
	public double getLength() {
		return 2*(length+wide);
	}	
}

public class B{
	public static void main(String[] args) {
		
		//声明父接口变量cir，指向子类对象
		IShape cir=new ICircle(5.0);
		
		//利用对象调用方法求面积和周长并输出
		System.out.print("圆面积："+cir.getArea());
		System.out.println("; 圆周长："+cir.getLength());
		
		//声明父接口变量rect，指向子类对象
		IShape rect=new IRectangle(6.5,10.8);
		
		//利用对象调用方法求面积和周长并输出
		System.out.print("矩形面积："+rect.getArea());
		System.out.println("; 矩形周长："+rect.getLength());
	}
}

四，枚举

1，举例应用

定义一个表示一周七天的枚举，并在主方法中遍历枚举所有成员

//定义一个名为Week的枚举类型
enum Week
    //声明7个枚举成员
{MONDAY,TUESDAY,WEDNESDAY,THUSDAY,FRIDAY,SATURDAY,SUNDAY}
    //定义主类
public class Person{
        //主方法
    public static void main(String[] args) {
        // [两种方法将枚举成员赋值给枚举型变量]
        // 1.定义一个枚举型变量 并赋给其一个枚举值
        Week a=Week.MONDAY ;
        // 2.用枚举名Week调用valueOf方法
        Week b=Week.valueOf("TUESDAY");
        //输出枚举变量的值
        System.out.print(a);
        System.out.println(" "+b);
        //利用foreach语句遍历枚举所有成员
        for(Week i:Week.values() ){
          System.out.println("序号: "+ i.ordinal()+" "+i);
        }
    }
}

2，利用foreach语句遍历输出各元素

结构  for(type element:array) {
	    System.out.println(element);
	    ..
	    ..
     }
举例  int[] arr= {1,2,3,4};
      for(int element :arr){
	    System.out.println(element);
	  }