java面向对象—抽象类与接口

一、final关键字在java中被称为完结器，表示最终的意思

二、final能声明类，方法，属性：

            使用final声明的类不能被继承

            使用final声明的方法不能被重写

            使用final声明的变量变成常量，常量是不能够被修改的（常量名所有大写）

抽象类

一、抽象类概念：

            包含一个抽象方法的类就是抽象类

二、抽象方法：

            声明而未被实现的方法，抽象方法必须使用abstract关键字声明

三、抽象类被子类继承，子类（若是不是抽象类）必须重写抽象类中的全部抽象方法

四、定义格式：

            abstract class className{

                        属性

                        方法

                        抽象方法

                }

五、抽象类不能直接实例化，要经过其子类进行实例化

package com.jk.classdemo;

abstract class Student{
	private String name;
	private int age;
	public void tell(){
		
	}
	public abstract void say();
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return the age
	 */
	public int getAge() {
		return age;
	}
	/**
	 * @param age the age to set
	 */
	public void setAge(int age) {
		this.age = age;
	}
	
}
class AbsDemo extends Student{
	public void say(){
		System.out.println("name:"+getName()+"  "+"age:"+getAge());
	}
}
public class AbstDemo01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		AbsDemo a=new AbsDemo();
		
		a.setName("ddd");
		a.setAge(20);
		a.say();
	}

}

接口

一、接口能够理解为一种特殊的类，里面所有是由全局常量（常量必须大写）和公共的抽象方法所组成

二、接口的格式：

                interface interfaceName{

                        全局常量

                        抽象方法

                    }

三、接口的实现也必须经过子类，使用关键字implements，并且接口是能够多实现的

package com.jk.classdemo;

interface inter1{
	public static final int AGE=30;
	abstract public void say();
}
interface inter2{
	public static final String NAME="zhangsan";
	abstract public void tell();
}
class Imp implements inter1,inter2{
	public void say(){
		System.out.println(AGE);
	}
	public void tell(){
		System.out.println("hello");
	}
}
public class InterDemo01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Imp im=new Imp();
		im.say();
		System.out.println(inter1.AGE);
		im.tell();
		System.out.println(inter2.NAME);
	}

}

四、一个子类能够同时继承抽象类和实现接口

package com.jk.classdemo;

interface inter1{
	public static final int AGE=30;
	abstract public void say();
}
interface inter2{
	public static final String NAME="zhangsan";
	abstract public void tell();
}
abstract class Abs1{
	public abstract void print();
} 
class Imp extends Abs1 implements inter1,inter2{
	public void say(){
		System.out.println(AGE);
	}
	public void tell(){
		System.out.println("hello");
	}
	public void print(){
		System.out.println("welcome");
	}
}
public class InterDemo01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Imp im=new Imp();
		im.say();
		System.out.println(inter1.AGE);
		im.tell();
		System.out.println(inter2.NAME);
		im.print();
	}

}

五、一个接口不能继承一个抽象类，可是却能够经过extends关键字同时继承多个接口，实现接口的多继承

interface inter1{
	public static final int AGE=30;
	abstract public void say();
}
interface inter2{
	public static final String NAME="zhangsan";
	abstract public void tell();
}
interface inter3 extends inter1,inter2{
	
}
abstract class Abs1{
	public abstract void print();
}