JavaSE07抽象类和接口

1.抽象类

抽象类的概念：每一个动物的吃和睡的功能不一样，不应该把动物类定义为一个具体类，而是给出一个声明(abstract),当一个类中如果有抽象功能（抽象方法），那么这个类一定要定义为抽象类。

<一个抽象类中可以有抽象方法也可以有非抽象方法>

2.抽象类的子类的特点：

a、抽象类的子类是抽象类，那么没有意义，最终使用的就是通过子类进行初始化的，如果子类都被抽象修饰了，那么也不能创建对象，所以没有意义。

b、抽象类不能实例化，抽象类不能创建对象

* 一个抽象类如何进行实例化？

答：通过抽象类多态的形式，父类的引用指向子类对象，通过子类进行初始化。

* 抽象类多态：通过子类必须重写当前抽象的父类中的所有抽象方法，还可以提高代码的维护性。

3.抽象类的成员特点：

成员变量：可以是变量也可以是自定义常量

构造方法：抽象类可以有构造方法（包括有参构造和无参构造）

作用：通过抽象类的多态的形式，让子类进行数据的初始化。

成员方法：可以有抽象方法也可以有非抽象方法。（抽象方法是没有方法体的方法）

abstract class Student{
  public void show(){
  Syetem.out.println("ssy");
   //有大括号包起来的方法体是具体方法
}
   public  abstract  void show(); //没有方法体的是抽象方法，此时该类不是抽象类会报错，应该给类中加上abstract声明

4.抽象类成员方法的特性：

抽象方法：强制子类要做的第一件事，方法重写（覆盖）。

非抽象方法：提高代码的复用性。

一个类中没有抽象方法，这个类也可以定义为抽象类，不能让其创建对象。

5.abstract不能和哪些关键字共同使用？

private final static（静态方法算不上方法重写） 不能和abstract一起使用，非法修饰报错，编译不通过。

实际开发中使用public或着protected来修饰。

6.接口（面向接口编程）

接口体现的是一种扩展功能，比如猫可以调高可并不是所有的猫都可以跳高。接口里的代码尽量越少越好。

接口的表示：interface 接口名{ }

接口的特点：不能是实例化（不能创建对象），那么接口如何进行实例化？

接口子实现类： a、接口的子实现类是抽象类：没有意义，子类都不能创建对象了。

                       b、接口的子实现类是非抽象类：接口的实例化通过子实现类对接口数据初始化。

接口成员的特点：a、成员变量：只能是常量，存在默认修饰符：public static final(永远建议自己给出)

                          b、构造方法：接口没有构造方法

                          c、成员方法：接口中的成员方法默认修饰符：public abstract(建议自己给出)

package org.zst.inter;
	//定义跳高的接口
	interface Jump{
		//非抽象方法:抽象类中不能有抽象方法
//		public void jump(){
//			System.out.println("猫可以跳高...");
//		}
		
		public abstract  void  jump() ;
		
		//构造方法:不能有
//		public Jump(){
//			
//		}
	}

	//子实现类是抽象类类
	//abstract class Cat implements Jump{
	//子实现类是非抽象类
	class Cat implements Jump{

		@Override
		public void jump() {
			System.out.println("猫可以跳高...");
		}
		
	}

	//测试类
	public class InterfaceDemo {
		public static void main(String[] args) {
			//创建接口对象
           //Jump j = new Jump() ;//接口不能实例化	
			//接口多态:接口的引用指向子实现类对象
			Jump j = new Cat() ;
			j.jump();
		}
	}

7.接口的子实现类和接口的关系：implements

格式：class  子实现名  implements  接口名

类与类的关系：继承关系 extends

类与接口的关系：实现关系 implemes ，并且一个类在继承另一个类的同时，可以实现多个接口。

            class  子实现类名 extends Object implements 接口名1,接口名2

接口与接口关系，继承关系 extends ，可以实现单继承也可以实现多继承。

8.接口与抽象类的区别

成员的区别：a、成员变量：

                                    抽象类：成员变量可以是常量也可以是变量。

                                    接口：   成员变量只能是一常量，存在默认修饰符 public static fianl

                   b、构造方法：

                                    抽象类：可以无参构造也可以有参构造（通过子类进行数据初始化即通过子类创建对象）

                                    接口：  没有构造方法

                   c、成员方法：

                                    抽象类：可以有抽象方法也可以有非抽象方法

                                    接口：只能是抽象方法 public abstract

关系的区别：类与类的关系：继承关系 extends

                   类与接口的关系：实现关系 implemes ，并且一个类在继承另一个类的同时，可以实现多个接口。

                   接口与接口关系，继承关系 extends ，可以实现单继承也可以实现多继承。

package org.zst.inter;
	interface Inter{
		public static final int num = 20 ;
		public static final  int num2 = 30 ;
		//抽象方法
//		public void show();
//		void show() ;
		//全部给出默认修饰符
		public abstract void show() ;
		//接口没有构造方法
//		public Inter(){	
//		}
		public abstract void function() ;
	}
	//定义接口的子实现类
	class InterImpl implements Inter{
		
		@Override
		public void show() {
			System.out.println(num);
			System.out.println(num2);
		}

		@Override
		public void function() {
			System.out.println("**********");
		}
	}
	public class Interface {
		public static void main(String[] args) {
			//创建接口对象:接口多态的形式
			Inter i = new InterImpl() ;
//			i.num = 50 ;//当前num变量:被final修饰,值不能改变
			System.out.println(Inter.num);//接口名.成员变量(当前变量被static修饰)
			System.out.println(Inter.num2);
			System.out.println("********");
			i.show() ;
			i.function() ;
		}
	}

9.如何使用API开发文档

使用API：打开API ------->显示（输入你要查找的类）-------->索引（搜索）

找到某一个类，看类结构，看该类是否有字段（变量），构造方法（如何创建对象），方法（类的成员方法），出现该类版本号：

JDK5.0以后的新特性，自动拆装箱(int------->Integer，char------->Character)，静态导入(导入的方法级别)，可变参数，增强for循环，枚举。

JDK7.0新特性：匿名内部类：局部内部类访问局部变量特性：局部变量必须被fianl修饰。

10.形式参数的情况

基本数据类型：你要什么类型，在实际传参的时候就会传什么数据类型，形式参数的改变对实际参数没有影响。（String类型虽然属于引用类型，但是和基本数据类型效果一样）

package org.zst.inter;
	class Zst{
		public int sum(int a,int b ){
			return a+b;	
		}
	}
	public class Test {
		public static void main(String [] args){
			//定义两个实际参数
			int a = 10;
			int b = 20;
			Zst z = new Zst();
			int result = z.sum(a, b);
			System.out.println(result);
		}
}

引用数据类型：

               具体类：如果形式参数是一个具体类，那么需要创建该类对象。

package org.zst.inter;
class Ssy{
	public void speak(){
		System.out.println("Ssy");
	}
}
class Ssy1{
	 public void show(Ssy s){  //形式参数是引用类型，只在栈内存开辟空间，需要创建Ssy类对象
		 s.speak();
	 }
}
public class Test1 {
	public static void main(String[] args){
		Ssy1 y = new Ssy1();
		Ssy s = new Ssy();
		 y.show(s); //直接传参报错，当前s变量不可用，没有对象;创建Ssy类对象只有s就作为Ssy类的对象，把空间地址值作为参数传递
	}
}

               抽象类：如果形式参数是抽象类的情况，那么需要自定义一个抽象的子类来进行实例化（创建对象）

package org.zst.inter;

abstract class Person1{
	public abstract void speak();
}
class  People{
	public void agree(Person1 p){
		p.speak();
	}
}
//自定义一个抽象的子类
class Person2  extends  Person1{
	public void speak(){
		System.out.println("ssy傻！");
	}
}
public class Person {
	public static void main(String[] args){
		People a  = new People();
		//a.agree(p);  //参数不能直接传过来 
		//Person1 b = new Person1();//抽象类不能实例化 ，会报错，通过定义一个抽象子类实例化
		Person1 p = new Person2(); //抽象类多态
		a.agree(p);
		//也可以链式编程
		new People().agree(new Person2());
	}
}	

               接口：方法的形式参数是一个接口，那么需要创建接口的子实现类对象（多态实例化）

package org.zst.inter;
interface In{
	public abstract void ssy();
}
class Cl{
	public void zst(In i){
		i.ssy();
	}
}
//接口不能实例化，需要创建接口的子实现类
class As implements In{
	@Override
	public void ssy() {
		System.out.println("我有几万里的山光想与你说 ");
		System.out.println("这沿途的星辰也想粒粒分明摘取下来  交由你");
		System.out.println("你   可以不可  等我");
	}
}
public class Inter {
	public static void main(String[] args){
		Cl c = new Cl();
		//创建子实现类接口对象
		In i = new As();//接口多态
		c.zst(i); //同理不能将参数直接传递过来，创建接口子实现类即可
	}
}

返回值：  

               具体类：直接返回该类对象（通常实际开发中使用匿名对象）

               抽象类：返回的是该抽象类的子类对象。

               接口：需要返回该接口的子实现类对象（通过子实现类进行实例化）