QQ登录

只需一步,快速开始

登录 | 立即注册 | 找回密码

主题

帖子

荣誉

新鱼友

Rank: 1

积分
75
查看: 121|回复: 0

[学习笔记] Java 笔记 接口 抽象 和关键字

[复制链接]
最佳答案
0 

尚未签到

可爱的静静 发表于 2017-8-10 20:05:23 1210 | 显示全部楼层 |阅读模式

马上注册加入鱼C,享用更多服务吧^_^

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
本帖最后由 可爱的静静 于 2017-8-13 18:37 编辑

抽象类的定义格式:
abstract class 类名
        {
                成员变量
                方法
                抽象方法
        }
成员方法 方法 抽象方法有,有没有根据自己需要来设计
        1、抽象类不能实例化,也就是不能new一个对象
        2、抽象类只能被继承
        3、抽象方法的定义格式:
                [修饰符] abstract 返回值类型 方法名(参数);
        4、一个类继承抽象类,就需要把抽象类中的抽象方法覆盖。否则这个子类也是抽象类,需要用
                abstract修饰


接口:
接口其实就是完全抽象的类,因此接口和类的地位是一样的,针对类的所有法则同样适用于接口。
接口所有的方法都是没有方法体的,而且所有方法都是默认public abstract  也就是接口那里面的方法全都是抽象方法,即使你没有这样声明,但默认是,接口是一个抽象类不能new  只能继承 而且要覆盖接口里的所有抽象方法,方法的访问全向必须大于或者等于父类抽象方法访问权限。而接口中的所有成员变量都是public static final的变量,并且必须要定义初始化,因为所有变量都必须在编译的时候有确定值。
接口定义的格式:
        interface 接口名
        {
                常量
                抽象方法
        }
有没有常量 抽象方法 都是根据自己需要定义
        1、接口不能被实例化,也就是不能new一个对象
        2、变量默认是:public static final可以省略
                要访问接口中的成员的格式:接口名.常量名
成员变量必须初始化,因为static修饰的所有变量都必须在编译的时候有确定值,final 就是修饰的变量一旦赋值就不可以改  而final修饰的。


        3、方法的定义格式:
                [public][abstract]返回值类型 方法名(参数);
                其中:public abstract可以省略  也就是方法全部都是抽象的 继承接口的子类必须全部继承方法
        4、一个类可以继承多个接口只继承一个父类
                class 子类 implements 接口1,接口2,...
                {
                        成员变量
                        方法
                }
类和接口的地位都一样
        5、可以把子类对象赋值给接口的引用,接口引用调用方法时执行的是子类的方法

编写2个接口: A和B;在接口A中有个方法void
printUp();在接口B中有个方法void printLower ();然
后写一个类Print实现接口A和B,要求printUp ()方法
实现输出大写英文字母表的功能,printLower ()方法实现输出小写英文
字母表的功能。
  1. public class Test {
  2.         public static void main(String[] args) {
  3.                 Interface  A  a = new Print();
  4. a.printUp ();
  5.                 System.out.println();
  6.                 InterfaceB b = new Print();
  7.                 b.printLower();
  8.         }
  9. }
  10. interface InterfaceA
  11. {
  12.         void printUp();
  13. }
  14. interface InterfaceB
  15. {
  16.         void printLower ();
  17. }
  18. class Print implements InterfaceA,InterfaceB
  19. {
  20.         public void printUp()

  21.         {
  22.                 for(int i='A';i<='Z';i++)
  23.                 {
  24.                         System.out.print((char)i + "  ");
  25.                 }
  26.         }
  27.         public void printLower ()
  28.         {
  29.                 for(int i='a';i<='z';i++)
  30.                 {
  31.                         System.out.print((char)i + "  ");
  32.                 }
  33.         }
  34. }
复制代码


static关键字:
        static关键字可以用于修饰成员变量,称为静态变量还可以修饰方法   
                                        [修饰符] static 数据类型 变量名[=值]
                                可以用于修饰方法,称为静态方法
                                        [修饰符] static 返回值类型 方法名(参数)
                                        {
                                                方法体
                                        }

   
        静态成员类似于一个全局的变量,在内存中只有一个,被所有对象所共享

        静态成员属于类的,而非静态的成员是属于对象的


在另一类中来访问当前的类的成员:
        1、另一类来访问当前类的静态成员的格式:类名.成员
        2、另一个类来访问当前类的非静态成员的格式:对象名.成员

同一个类中的方法
        静态方法来访问成员:
                1、被访问的成员是静态,可以直接访问
                2、被访问的成员是非静态的,需要用 对象名.成员
        3静态方法只能访问静态成员
4静态方法中不可以写this,super关键字

        非静态方法访问成员变量
                1、被访问的成员是静态,可以直接访问
                2、被访问的成员是非静态的,直接访问的是自己对象的成员
                        若要访问其它对象的成员,则需要用 对象名. 成员变量
3静态方法可以访问静态和非静态变量
       
  1. public class Test {
  2.         public static void main(String[] args) {
  3.                 System.out.println(A.age);
  4.                 A a = new A();
  5.                 System.out.println(a.name);
  6.                 a.output();
  7.         }
  8. }
  9. class A
  10. {
  11.         static int age = 12;
  12.         String name="小妞";
  13.         static void disp()
  14.         {
  15.                 System.out.println(age);
  16.                 A b = new A();
  17.                 System.out.println(b.name);
  18.         }
  19.         void output()
  20.         {
  21.                 System.out.println(age);
  22.                 System.out.println(name);
  23.                 A c = new A();
  24.                 System.out.println(c.name);
  25.         }
  26. }
复制代码

final关键字
1、用final修饰变量,就为常量,就需要初始化,并且后面不可以修改
        public class Test {
                public static void main(String[] args) {
                        A a = new A();
                        System.out.println(a.age);
                        a.age=34;//error
                }
        }
        class A
        {
                final int age = 12;
               
        }

2、用final修饰方法,表示这个方法不能被覆盖
        class A
        {
                final void disp()
                {}
        }
        class B extends A
        {
                void disp()  //error
                {
                       
                }
        }
3、用final修饰类,表示这个类不能被继承
        final class A
        {
                 void disp()
                {}
        }
        class B extends A  //error
        {
                void disp()
                {
                       
                }
        }



评分

参与人数 1鱼币 +3 收起 理由
小甲鱼 + 3

查看全部评分

楼层
跳转到指定楼层

发表回复

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

关闭

小甲鱼强烈推荐 上一条 /1 下一条

    移动客户端下载(未启用)
    微信公众号

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备11014136号

Copyright 2018 鱼C论坛 版权所有 All Rights Reserved.

Powered by Discuz! X3.1 Copyright
© 2001-2018 Comsenz Inc.    All Rights Reserved.

小黑屋|手机版|Archiver|鱼C工作室 ( 粤公网安备 44051102000370号 | 粤ICP备11014136号

GMT+8, 2017-12-19 06:11

快速回复 返回顶部 返回列表