Java教程

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);
	  }
这篇关于Java学习———继承,抽象类,接口,枚举的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!