java面向对象（抽象、接口）

目录

抽象

        概念

      特点

        语法

            代码

        总结

接口

        接口简介

        特点

        重写方法时

       接口语法

        类和接口之间的关系

        代码示例

---

抽象

        概念

                在面向对象的概念中,所有的对象都是通过类中描绘的,但是反过来,并不是所有的类

                        都是使用描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象

                        这样的类就是抽象类

                抽象类除了不能实例化对象之外,类的其他功能依然存在,类的其他功能依然存在

                        成员变量,成员方法和构造方法的访问方式和普通类一样

                由于抽象类不能实例化,所以抽象类必须被继承,才能被使用

                java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类

                        而一个类却可以实现多个接口

                抽象就是把具有相同的属性和行为，给提取出来，然后创建新类的过程

                        抽象：即看不懂的事物

      特点

                1.抽象方法一定在抽象类中

                2.抽象方法和抽象类都必须被abstract关键字修饰

                3.抽象类不可以用new创建对象，因为调用抽象方法没意义

                        （抽象方法没有方法体）

                4.抽象类中的抽象方法要想被使用，

                        必须由子类重写其子类所有的抽象方法后才能建立子类对象，

                        如果子类覆盖部分抽象方法，那么该子类还是一个抽象类

                自我:

                        当继承了一个抽象类,那么就有两种方法

                        一个是把子类变成抽象类,另一个是重写所有抽象方法

        语法

                

        //修饰类

      abstract class 类名{

      }

        //修饰方法

    访问修饰符 abstract 返回值 方法名();

                注意:

                        abstract不能和static同时出现在一个方法上

                        abstract不能和native同时出现在方法上

                        abstract不能和synchronized同时出现

                        不能和final和private修饰符在一起

            代码

public class AbstractTask1 {
	public static void main(String[]args) {
		//不能new抽象类
		//Animal animal=new Animal();
		Animal animal=new Dog("小黄");
		animal.show();
		animal.info();
	}
}
//抽象类（父类）
abstract  class Animal{
	public String name;
	public Animal() {
		
	}
	public Animal(String name) {
		this.name=name;
	}
	public  void show() {
		System.out.println("我是Animal中的类");
	}
	public abstract void info();
	//public static abstract void  a (); 不能和static一起使用
	//public abstract Animal(int i) { 不能使用abstract修饰构造方法
	//
	//}
	public abstract void b(); 
}
//继承Animal抽象类
class Dog extends Animal {
	public Dog() {
		
	}
	public Dog(String name) {
		super(name);
	}
	public void show() {
		System.out.println("我是Dog中的类");
	}
	@Override
	public void info() {
		System.out.println("我叫"+name+",我是一条狗");
	}
	@Override
	public void b() {
		// TODO Auto-generated method stub
		
	}
	
}

        总结

                抽象类不能被实例化，只有抽象类的非抽象子类可以创建对象

                抽象类中不一定包含抽象方法，但是抽象方法的类必定是抽象类

                抽象类中的抽象方法只是声明，不包含方法体

                构造方法，类方法（用static修饰的方法）不能声明为抽象方法

                抽象类的子类必须给抽象类中的抽象方法的具体实现，除非该子类也是抽象类

接口

        接口简介

                在java当中接口是一个抽象类型，是抽象方法的集合，一个类通过实现接口的方式

                        来实现接口当中的抽象方法

                接口里面包含要实现的方法，除非实现接口的类是抽象类

                        否则该类要定义接口中的所有方法

                接口无法被实例化，但是可以被实现，一个实现接口的类，必须实现接口内所

                        描述的所有方法，否则就必须声明为抽象类或接口。

        特点

                接口当中定义的属性是常亮，方法是抽象方法

                属性修饰符public static final 方法：public abstract

                接口当中不能包含今天代码块，以及静态方法

                接口使用implements来实现（继承）接口，java支持多实现

                注意：如果不写修饰符，接口会默认补上

                                接口也是不能创建对象的

        重写方法时

                类在实现接口的方法时，不能抛出强制性异常，只能在接口中

                或者继承接口的抽象类中抛出该强制性异常。

                抛出的异常不能大于抽象方法抛出的异常

       接口语法

                [  ]里面的内容表示可选

//定义接口

public interface 接口名{

        //定义属性

        //[     修饰符     ]   返回值 名称=值；

        public static final String name="";

        String name2="";

        //定义方法

        //[    修饰符    ] 返回值 方法名();

        public abstract void abc();

        void abc2();

}

//使用接口

class 类 implements 接口名称[,其它接口,……]{

}

                注意

                        在接口当中声明属性和方法的时候，可以使用简写的方式，系统会自动补全

                        属性：类型 名称 = 值；

                        方法：返回值类型 方法名(参数列表);

                声明在接口里面的属性都是常亮，而方法都是抽象方法

        类和接口之间的关系

                类与类之间：继承

                类与接口之间：实现

                接口与接口之间：继承

        代码示例

public class InterfaceTas1 {
	public static void main(String[]args) {
		Birdie birdir=new Birdie();
		birdir.c();
	}
}
interface Fly{
	//不加上特定的修饰符，系统会默认加上变成常亮
	//默认加上：public static fianl
	public static final String name="Fly";
	String age="年龄";
	//不加上特定的修饰符，系统会默认变成抽象方法
	//加上public abstract
	public abstract void a()  ;
	//这个跟上面是一样的，我们没有写上修饰符，只不过系统会默认加上
	void b();
	//子类在实现接口的时候不能抛出异常，只能在接口当中抛出异常
	void c() throws FileNotFoundException;
}
class Birdie implements  Fly {
	public static final String name="Birdie";
	public Birdie() {
		//接口当中不能定义构造方法,但是子类能够调用，没意义
		super();
	}
	@Override
	public void a() {
		// TODO Auto-generated method stub
		System.out.println("我是Birdie类的C方法");
	}

	@Override
	public void b() {
		// TODO Auto-generated method stub
		System.out.println("我是Birdie类的B方法");
	}
	@Override
	//不能比父类抛出更加广泛的异常
	public void c()   {
		try {			
			//不能通过super.来调用接口当中的属性
			System.out.println("我是Birdie类的C方法"+name+age+"");
			//当子类有父类相同的静态变量时，会先访问子类静态变量
		}catch(Exception E) {
			E.printStackTrace();
		}
		// TODO Auto-generated method stub
	}
 }