Java基础---接口

Java基础---接口

1.接口

1.通过interface关键字修饰的java元素就是接口。

  格式：ublic  interface  接口名{}

             interface  接口名{}

2.为什么要有接口？ 

为了克服java的单继承，接口可以被实现多个

例如:收费，出租车有收费功能【1元/公里】，飞机有收费功能【全程1000元】

出租车与飞机不是同一类事物，但是有相同的功能

  接口实际上就是提供不同类型事物的公共内容，由接口的子类根据自身的实际情况，来实现

这个接口提供的公共内容。这样子类就不需要创建这个公共内容，只需要继承来重写一下就

好。

3.接口中的元素 

接口中可以有变量量、静态方法、抽象方法。

  1、接口中变量一定是 public static  final修饰的。

  2、接口中的静态方法一定是public修饰的，public可以被省略

  3、接口中的抽象方法一定是public  abstract修饰的，public  abstract可以省略

package com.object.test5;
//接口
public interface TestInterface {
           //接口中的变量一定是public static final修饰的
	      static int id=1001;
	      String name="zhangsan";
	       public int age=23;
	       
	       //接口中的静态方法一定是public修饰的，public可以被省略。
	       static void  staticMethod(){
	    	   System.out.println("接口中的静态方法");
	       }
	       //接口中的抽象方法一定是public  abstract修饰的，public  abstract可以省略
	       void abstractMethod();
}

package com.object.test5;
//测试接口中的变量和方法
public class TestMain {

	public static void main(String[] args) {
		System.out.println(TestInterface.id);
		System.out.println(TestInterface.name);
		System.out.println(TestInterface.age);
		TestInterface.staticMethod();

	}

}

4.接口的用法

1.接口不能new，如果需要访问抽象方法需要接祖接口的子类

2.类可以通过implements关键字去实现一个/多个接口

3.普通类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个

普通类改为抽象类

4.抽象类去实现一个/多个接口，不需要重写接口中的抽象方法

5.接口可以继承接口，并且继承父接口中的所有元素

6.利用接口回调对象创建接口对象

7.当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以

是接口的子类对象

package com.object.test5;

public class Person implements TestInterface,DoInterface{
	        //重写TestInterface中的抽象方法
	       public void abstractMethod(){
	    	   
	       }
	       //重写DoInterface中的抽象方法
	       public void doMethod(){
	    	   
	       }
}

5.接口回调对象

 接口回调对象与上转型对象很相似

接口回调对象---接口的子类对象赋值给接口变量

1.接口回调对象只能访问接口的抽象方法，实际上访问子类重写以后的抽象方法

2.接口回调对象不能访问子类本上的方法，如需访问就需要强制类型转换

package com.object.test6;
//接口
public interface TestInterface {
          void  info();
}

package com.object.test6;
//子类
public class TestSonClass implements TestInterface {
	@Override
	public void info() {
		System.out.println("TestSonClass重写接口的抽象方法");
	}

	public void test1() {
		System.out.println("子类本身的实例方法");
	}
}

package com.object.test6;
//测试接口
public class TestMain {

	public static void main(String[] args) {
		// 接口不能new，如果需要访问抽象方法需要借助接口子类
		
		//接口回调对象--接口的子类对象赋值给接口变量
		TestInterface tin=new TestSonClass();
		tin.info();
		//接口回调对象只能访问接口的抽象方法，实际上访问子类重写以后的抽象方法
		//接口回调对象不能访问子类本身的方法，如果要访问就需要强制类型转换
		TestSonClass tc=(TestSonClass)tin;
		tc.test1();
	}

}

6.抽象类与接口的区别?

抽象类接口abstract classinterfaceendents 一个implements 多个提供同类型事物的公共内容    提供不同类型事物的公共内容    抽象类中的元素实例变量、类变量【静态变量】构造方法、实例方法、类方法【静态方法】、【抽象方法】接口中可以有类变量、JDK8.0类方法、抽象方法。且都是public修饰符修饰的。

7..static  静态修饰符

1.static修饰的变量就是静态成员变量，可以类名访问，也可以对象访问

2.static修饰的方法就是静态方法，可以类名访问，也可以对象访问

3.同一个类中静态方法不能访问实例元素，this不能出现

package com.object.test8;

public class TestClass {
	              //静态成员变量
                 public static int id=1001;
                 //实例变量
                 public  String name="zhangsan";
                 
                 public  void shiliMethod(){
                	 System.out.println("实例方法");
                	 System.out.println("fangwen"+this.id);
                 }
                 //静态方法
                 public static void Method(){
                	 System.out.println("静态方法");
                	 //同一个类中静态方法不能访问实例元素
                	 //System.out.println("fangwen"+name); //报错
                	 //System.out.println("fangwen"+this.id);  //报错
                	 System.out.println("静态方法"+id);
                 }
}

package com.object.test8;

public class TestMain {

	public static void main(String[] args) {
		//创建对象
		TestClass tcl	=new TestClass();
		//static修饰的访问是静态方法，可以类名访问，也可以对象访问
		tcl.Method();
		TestClass.Method();
		//static修饰的变量是静态成员变量，可以类名访问，也可以对象访问
		System.out.println("id=="+TestClass.id);
		System.out.println("id=="+tcl.id);

	}

}

8. this 当前类对象

1.出现在哪个类中就是哪个类的对象

2.在当前类中的构造方法/实例方法中访问当前类中的变量和方法，可以省略

3.在当前类中的构造方法/实例方法中访问被隐藏的成员变量时不能省略。

package com.object.test8;

public class TestClass {
	              //静态成员变量
                 public static int id=1001;
                 //实例变量
                 public  String name="zhangsan";
                 //成员变量
                 public String name2="lisi";
                 
                 //构造方法
                 public  TestClass(){
                	 System.out.println("构造方法");
                	 //在当前类中的构造方法/中访问当前类中的变量和方法，可以省略
                	 System.out.println("this构造方法"+this.name);
                	 System.out.println("f构造方法"+name);
                 }
                 //实例方法
                 public  void shiliMethod(){
                	 String name2="wanfwu";
                	 System.out.println("实例方法");
                	 //在当前类中的构实例方法中访问当前类中的变量和方法，可以省略。
                	 System.out.println("this实例方法=="+this.id);
                	 System.out.println("实例方法=="+id);
                	 System.out.println("局部变量name2=="+name2);
                	 System.out.println("成员变量name2=="+this.name2);
                 }
                 //静态方法
                 public static void Method(){
                	 System.out.println("静态方法");
                	 //同一个类中静态方法不能访问实例元素
                	 //System.out.println("静态方法"+name); //报错
                	 //System.out.println("静态方法"+this.id);  //报错
                	 System.out.println("静态方法=="+id);
                 }
}

package com.object.test8;

public class TestMain {

	public static void main(String[] args) {
		//创建对象
		TestClass tcl	=new TestClass();
		//static修饰的访问是静态方法，可以类名访问，也可以对象访问
		//访问静态方法
		tcl.Method();
		TestClass.Method();
		//访问实例方法
		tcl.shiliMethod();
		//static修饰的变量是静态成员变量，可以类名访问，也可以对象访问
		//访问静态成员变量
		System.out.println("静态成员变量id=="+TestClass.id);
		System.out.println("静态成员变量id=="+tcl.id);
		//访问实例变量---只能对象访问
		System.out.println("实例变量name=="+tcl.name);
		//System.out.println("实例变量name=="+shiliMethod.name); //报错


	}

}

9. super 父类的对象

1.出现在子类中的构造方法第一句，super()父类无参数的构造方法/super(参数)父类有参数构

造方法

2.出现在子类中的实例方法中，表示访问父类的变量/方法

访问被隐藏的父类变量，super.变量名称，此时这个super表示父类的对象

一般指访问没有重写之前的父类方法，super.方法名称([参数])，此时这个super表示父类对象

package com.object.test8;

public class TestFatherClass {
                public TestFatherClass(){
                	System.out.println("无参数的构造方法");
                }
                public TestFatherClass(String name){
                	System.out.println("有参数的构造方法--"+name);
                }
}

package com.object.test8;

public class TestSonClass extends TestFatherClass{
	public TestSonClass(){
		super ("zhangsan");
		System.out.println("子类的构造方法");
	}
}

10. final  终极修饰符

1.fianl修饰的类，不能被继承，没有子类

package com.object.test7;

public final class FinalClass {
	 public final void Merhod2(){
  	   System.out.println("FinalClass中的是实例方法");
}
}

package com.object.test7;
//报错
public class FinalSonClass extends FinalClass  {
	 
}

2.fianl修饰的变量，就是常量，不能被重新赋值

papackage com.object.test7;

public class TestMain {

	public static void main(String[] args) {
		
		int id1=1001;
		System.out.println("id=="+id1);
		id1=1002;
		System.out.println("id=="+id1);
		//被fianl修饰的变量，就是常量，不能被重新赋值
		final int id2=1003;
		System.out.println("id=="+id2);
		//id2=1002;  //报错
		//System.out.println("id=="+id2);

	}

}

3.fianl修饰的方法，不能被重写。

package com.object.test7;

public class TestClass {
         
}



package com.object.test7;

public class TestSonClass extends TestClass{
	   public  void Merhod(){
 	      System.out.println("重写TestClass中的方法");
      }  
}