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.抽象类与接口的区别?
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中的方法"); } }
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)