JavaSE(四)之接口、访问控制

上面我们学习了几个修饰符,在开发中经常会用的到,所以必须熟练的掌握。接下来我学习一下接口和访问控制。

一、接口

一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。

1.1、接口与抽象类的区别

抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。接口已经另一种类型了,和类是有本质的区别的,所有不能用类的标准去衡量接口。 声明类的关键字是class,声明接口的关键字是interface。  抽象类是用来被继承的,java中的类是单继承。               类A继承了抽象类B,那么类A的对象就属于B类型了,可以使用多态               一个父类的引用,可以指向这个父类的任意子类对象               注:继承的关键字是extends 接口是用来被类实现的,java中的接口可以被多实现。               类A实现接口B、C、D、E..,那么类A的对象就属于B、C、D、E等类型了,可以使用多态               一个接口的引用,可以指向这个接口的任意实现类对象               注:实现的关键字是implements

1.2、接口中的方法都是抽象方法

 接口中可以不写任何方法,但如果写方法了,该方法必须是抽象方法           例如:           public interface Action{ public abstract void run();               //默认就是public abstract修饰的               void test();               public void go();           }

 1.3、接口中的变量都是静态常量(public static final修饰)

接口中可以不写任何属性,但如果写属性了,该属性必须是public static final修饰的静态常量。           注:可以直接使用接口名访问其属性。因为是public static修饰的           例如:           注:声明的同时就必须赋值.(因为接口中不能编写静态代码块)           public interface Action{               public static final String NAME = "tom";               //默认就是public static final修饰的               int AGE = 20;           }           main:               System.out.println(Action.NAME);               System.out.println(Action.AGE);

  1.4、一个类可以实现多个接口 

 1 public class Student implements A,B,C,D{
 2             //Student需要实现接口A B C D中所有的抽象方法
 3             //否则Student类就要声明为抽象类,因为有抽象方法没实现
 4         }
 5         main:
 6             A s1 = new Student();
 7             B s2 = new Student();
 8             C s3 = new Student();
 9             D s4 = new Student();
10 
11             注:
12             s1只能调用接口A中声明的方法以及Object中的方法
13             s2只能调用接口B中声明的方法以及Object中的方法
14             s3只能调用接口C中声明的方法以及Object中的方法
15             s4只能调用接口D中声明的方法以及Object中的方法
16 
17             注:必要时可以类型强制转换
18             
19             例如:
20             接口A 中有test()
21             接口B 中有run()
22 
23             A s1 = new Student();
24             s1.test();
25 
26             B s2 = new Student();
27             s2.run();
28             
29             if(s1 instanceof B){
30                 ((B)s1).run();
31             }

  1.5、一个接口可以继承多个父接口

 1 public interface A{
 2             public void testA();
 3         }
 4 
 5         public interface B{
 6             public void testB();
 7         }
 8         
 9         //接口C把接口A B中的方法都继承过来了
10         public interface C extends A,B{
11             public void testC();
12         }
13         
14         //Student相当于实现了A B C三个接口,需要实现所有的抽象方法
15         //Student的对象也就同时属于A类型 B类型 C类型
16         public class Student implements C{
17             public viod testA(){}
18             public viod testB(){}
19             public viod testC(){}
20         }
21 
22         main:
23         C o = new Student();
24         System.out.println(o instanceof A);//true
25         System.out.println(o instanceof B);//true
26         System.out.println(o instanceof C);//true
27         System.out.println(o instanceof Student);//true
28         System.out.println(o instanceof Object);//true
29         System.out.println(o instanceof Teacher);//false

  //编译报错         System.out.println(o instanceof String);         注:         System.out.println(o instanceof X);    如果o是一个接口类型声明的变量,那么只要X不是一个final修饰的类,该代码就能通过编译,至于其结果是不是true,就要看变量o指向的对象的实际类型,是不是X的子类或者实现类了。         注:一个引用所指向的对象,是有可能实现任何一个接口的。(java中的多实现)

  1.6、接口的作用  

    接口的最主要的作用是达到统一访问,就是在创建对象的时候用接口创建,【接口名】 【对象名】=new 【实现接口的类】,这样你像用哪个类的对象就可以new哪个对象了,不需要改原来的代码。

    假如我们两个类中都有个function()的方法,如果我用接口,那样我new a();就是用a的方法,new b()就是用b的方法

    这个就叫统一访问,因为你实现这个接口的类的方法名相同,但是实现内容不同

  总结:    

1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)

    2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化

    3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法

    4、接口中没有构造方法,不能被实例化

    5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口

    6、Java接口必须通过类来实现它的抽象方法

    7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类

    8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例

    9、  一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.

  1.7、实例  

 1 package com.frewen.interfacedemo;
 2 
 3     interface SwimInterface{   
 4        void swim();
 5     }
 6     class   Fish{   
 7        int  fins=4;
 8     }
 9     class  Duck {   
10       int  leg=2;
11       void egg(){};
12     }
13     
14     class Goldfish extends Fish implements  SwimInterface {
15         @Override
16         public void swim() {
17              System.out.println("Goldfish  can swim ");
18         }  
19     }
20     
21     class SmallDuck  extends Duck implements  SwimInterface { 
22        public void egg(){
23            System.out.println("SmallDuck  can lay  eggs ");
24        }
25        @Override
26        public void swim() {
27            System.out.println("SmallDuck  can swim ");
28        }
29     }
30 
31     public class InterfaceDemo {        
32         public static void main(String[] args) {
33             Goldfish goldfish=new Goldfish();
34             goldfish.swim();
35 
36             SmallDuck smallDuck= new SmallDuck();
37             smallDuck.swim();
38             smallDuck.egg();
39     }
40 }

二、访问控制

    public protected default private是java中的访问控制修饰符.       注:这里的default的意思是什么都不写           例如:           public String name;           protected String name;           //default就表示这种情况           String name;           private String name;

  2.1、修饰类

    1)普通类

只能使用public和default来修饰源文件中编写的java类               public表示其他任何地方都有权限访问这个类               default表示只有和当前类在同一个包的类才有权限访问

    例如: Test.java中有俩个类

 1 public class Test{
 2                     private class A{}
 3                     class B{}
 4                     protected class C{}
 5                     public class D{}
 6                 }
 7 
 8                 class Action{}
 9 
10                 //编译报错
11                 protected class Action2{}
12                 private class Action3{}

    2)内部类

    四个修饰符可以修饰特定的内部类

1 //四个内部类
2                 public class Test{
3                     private class A{}
4                     class B{}
5                     protected class C{}
6                     public class D{}
7                 }

  2.2、修饰属性和方法

    四个修饰都可以修饰类中的属性和方法,那么就以修饰属性为例来说明.(效果和修饰方法是一样的)

    public class Person{             public      String pubStr = "pubStr";             protected String proStr = "proStr";             String defStr = "defStr";             private   String priStr = "priStr";         }         从四个地方测试这些属性的可见性:                     类中     同包类中    子类中    不同包类中         public         Y            Y            Y            Y         protected     Y            Y            Y            N         default         Y            Y            N            N         private         Y            N            N            N             注:这里的子类中默认指的是不同包下面的子类

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏wym

运算符重载(超详细)

C++中预定义的运算符的操作对象只能是基本数据类型。但实际上,对于许多用户自定义类型(例如类),也需要类似的运算操作。这时就必须在C++中重新定义这些运算符,赋...

1162
来自专栏工科狗和生物喵

【计算机本科补全计划】Java学习笔记(三) 数据类型

正文之前 Java的面向对象特性太明显了。先开篇告诉你我们的对象是啥意思,然后直截了当的告诉你,每个文件都是一个类。也就是说每个文件都可以给你传出来一种对象,然...

3534
来自专栏吾爱乐享

java之学习Integer类相关面试题

1384
来自专栏一“技”之长

Swift讲解专题七——函数 原

        函数是有特定功能的代码段,函数会有一个特定的名称调用时来使用。Swift提供了十分灵活的方式来创建与调用函数。事实上在Swift,每个函数都是一...

733
来自专栏JetpropelledSnake

Python面试题之Python中的类和实例

类,在学习面向对象我们可以把类当成一种规范,这个思想就我个人的体会,感觉很重要,除了封装的功能外,类作为一种规范,我们自己可以定制的规范,从这个角度来看,在以后...

982
来自专栏Vamei实验室

Java进阶04 RTTI

运行时类型识别(RTTI, Run-Time Type Identification)是Java中非常有用的机制,在Java运行时,RTTI维护类的相关信息。 ...

2007
来自专栏Java 源码分析

静态内部类

定义:静态内部类,定义在类中,任何方法外,用static定义;静态内部类只能访问外部类的静态成员。 注意点: 一般情况下,如果一个内部类不是被定义成静态内部类,...

3148
来自专栏前端正义联盟

一道 js 闭包面试题的学习

最近看到一条有意思的闭包面试题,但是看到原文的解析,我自己觉得有点迷糊,所以自己重新做一下这条题目。

3474
来自专栏前端小叙

js数组push方法使用注意

js 数组的push方法,想必大家都知道是向数组末尾添加元素,但是有一个很关键的点需注意: 引自 MDN 返回值 当调用该方法时,新的 length 属性值将被...

3566
来自专栏静默虚空的博客

[Java 基础]方法

方法的定义 Java方法是语句的集合,它们在一起执行一个功能。 方法是解决一类问题的步骤的有序组合 方法包含于类或对象中 方法在程序中被创建,在其他地方被引用 ...

1967

扫码关注云+社区