精华内容
下载资源
问答
  • 什么是剑桥少儿英语?...虽然剑少一级比较简单,但多少还是涉及到一些语法点。到了二级YLE Mover,语法知识要求就更高了,一般过去式、比较级、最高级都要求掌握了。但是,语法这么抽象,怎样才能让低...

    什么是剑桥少儿英语?

    剑桥少儿英语考试,是英国剑桥大学考试委员会特别为测试7-12岁少儿的英语水平而设计的一套测试系统。一级(Starters), 二级(Movers)和三级(Flyers)虽然名额要靠秒杀,但这个考试仍持续火爆。

    虽然剑少一级比较简单,但多少还是涉及到一些语法点。到了二级YLE Mover,语法知识要求就更高了,一般过去式、比较级、最高级都要求掌握了。

    但是,语法这么抽象,怎样才能让低幼年龄的孩子理解、掌握、记住呢?还是要有系统的、按照一定步骤,用符合孩子认知规律的方式去学习。一套好的教材至关重要,如果只能选用一套,那非牛津《Grammar Friends和语法做朋友》莫属!

    Grammar Friends

    《Grammar Friends》是牛津大学出版社专门为非母语国家孩子编写的语法专项学习书,覆盖了小学到初中的基本语法点。

    它的宗旨是:让孩子和语法做朋友,从初学英语开始就系统而循序渐进地学语法,内容和深度螺旋上升,为孩子构建一条完整的基础语法学习之路。每个语法点,都按“场景引入—规则总结—应用练习”这条路径去学,让孩子学得懂,记得牢!

    dcb899a0-482a-eb11-8da9-e4434bdf6706.png

    本文就列举几个剑少各级考试的语法点,看看《Grammar Friends》中是怎么带大家学习的吧!

    剑少一级中最常见的就是一般现在时和现在进行时。在《Grammar Friends》中采用难度螺旋上升的方式不断巩固。

    01

    一般现在时

    《Grammar Friends》里分了好几课内容,在第一、二册里展开。

    例如be动词

    第一册Unit 2、Unit3中先单独介绍了i、sam和are。

    用对话引入场景,并红字标注出了is、are引起注意。之后,用例句分别列出了肯定句、一般疑问句、肯定和否定的回答形式。

    然后通过连线让孩子们熟悉肯定、否定的回答形式。

    再利用句子排序再强化is在句首的一般疑问句。最后,是书写练习,让孩子们进一步掌握yes,it is和no,it isn't。

    第二册Unit2中,加深了难度,对话中is am are都出现了,目的就是让孩子们在应用中对三者的区分更加清晰。并且罗列了不同人称代词后的be动词和缩写。

    在练习部分,先从最简单的找出be动词入手,再到一小段文章里的填空,最后根据图示写出完整的短句。

    第二册,更全面的介绍了一般现在时的其他类型。Unit 3中,介绍了情态动词can,Unit6、7、8分别介绍了含实义动词的谓语动词

    第三册中,又出现了一般现在时be动词的否定形式。以及动词的否定形式、疑问句形式。还归纳了动词+s的几种规律。并把一般现在时和一般过去式进行了对比,帮助孩子们区分两者。

    02

    现在进行时

    对于现在进行时,《Grammar Friends》 就把它拆开,分四次来学。

    第2册Unit11、12中先熟悉这个时态的含义,它表示正在发生的动作:talk about things that are happening now;直接在动词后加 -ing,就能表示现在进行时了(wear - wearing)。

    第3册增加了这个时态下的更多动词变化规则了,除了第二册里学到的直接 ing 方式之外,还有两种变化,有的在加 -ing的时候要去掉字母 e(writing),有的要双写最后一个字母(snokelling)。

    第4册把现在进行时和一般现在时放在一起学,让孩子在对比中理解两个时态不同的应用场景 ...

    第5册中,增加了现在进行时表示将来要做某事的意思。

    这样一步步的,把“现在进行时”最朴素的用法和更高级的用法逐渐学下来,每一步都不复杂,每一步都很扎实,前后连在一起,理解层层递进,用法越来越活,这才是学语法的“王道”。

    03

    一般过去式

    剑少二级中,最大的语法点就是一般过去式。在《Grammar Friends》的第3、4两册中,对这个语法点分数课进行了讲解。

    首先在第3册中,Unit12、13、14分别对be动词过去式was/were、have的过去式had和直接+ed/d的动词过去式、一般疑问句开展专门练习。

    第4册中,Unit2巩固了这三类过去式的用法。首先从一个场景中引入,这幅图里展现了剧院里的场景。例句里四个动词被标注加粗 were, had, acted, clapped, 提醒孩子注意动词发生变化了。场景式的引入后,列出了“一般过去时”动词的三种变形规律。这里,场景和规则紧密结合在一起,让孩子的认识从“感性”走向“理性”,从现象观察走向规律总结。

    了解了规则,接着就是练习。只有通过大量的实际使用,孩子对语法点的理解和记忆才会得到提升。大量设计科学的练习,是不可缺少的,对于缺乏语言环境的外语孩子尤其如此。

    在Unit3,还增加了动词不规则变化的过去式。(在剑少二级中,不规则变化的动词有55个之多!),以及疑问句里的did用法

    对于更为复杂的例如过去完成时、现在完成时、将来完成时等等,《Grammar Friends》同样采用循序渐进的方式学习。在第五册中,又在情境中将一般过去式和现在完成时进行了对比,以加深理解。

    此外,Grammar Friends 里每三个单元会设置一套复习题,每本书最后有 Grammar Reference ,总结了这一册的核心语法规则,孩子可以快速查到让自己困惑的语法点,针对性地解决问题。

    总之,这套书既可以作为独立的语法教材,也可以作为课外练习使用。结合学校课本,Grammar Friends 可以帮孩子大大拓展语法的学习内容,真正学懂、学透;记住、会用。搞定这里的学习,小学语法应该可以轻松过关,还能早些开始初中以上的语法学习,让孩子领先一步。

    展开全文
  • Java 基础语法 Java编程规范 Java 标识符 命名规则: Java修饰符 访问控制修饰符 默认访问修饰符-不使用任何关键字 私有访问修饰符-private 非访问修饰符 static 修饰符 final 修饰符 final ...

    目录

     

    Java 基础语法

        Java编程规范

        Java 标识符

        命名规则:

        Java修饰符

        访问控制修饰符

        默认访问修饰符-不使用任何关键字

        私有访问修饰符-private

        非访问修饰符

        static 修饰符

        final 修饰符

        final 方法

            final 类

        abstract 修饰符

        抽象方法

            transient 修饰符

        Java 变量

        局部变量

            类变量(静态变量)

        实例变量

    成员变量、局部变量、静态变量的区别

     Java 数组

        Java注释

        注释规范

        1、类注释

        2、属性注释

        3、方法注释

        4、构造方法注释

        5、方法内部注释

        Java 空行

        继承

        接口


    Java 基础语法

        一个 Java 程序可以认为是一系列对象的集合,而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

        对象:对象是类的一个实例,有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。

        类:类是一个模板,它描述一类对象的行为和状态。

        方法:方法就是行为,一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。

        实例变量:每个对象都有独特的实例变量,对象的状态由这些实例变量的值决定。

        编写 Java 程序时,应注意以下几点:

        大小写敏感:java是大小写敏感的,这意味着标识符Hello与hello是不同的

        类名:对于所有的类来讲,类名的首字母应该大写。如果类名由若干单词组成那么每个单词的首字母应该大写。

        方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词那么后面的每个单词的首字母大写

        源文件名:源文件名必须和类名相同。当保存文件的时候,应该使用类名作为文件名保存,文件名的后缀为.java(文件名和类名不相同会导致编译错误)

        主方法入口:所有的java程序由public static void main(String[]args)方法开始执行。

        Java编程规范

        package的命名: package 的名字由全部小写的字母组成,例如:com.runoob。

        class和interface的命名: class和interface的名字由大写字母开头而其他字母都小写的单词组成,例如:Person,RuntimeException。

        class变量的命名: 变量的名字用一个小写字母开头,后面的单词用大写字母开头,例如:index,currentImage。

        class 方法的命名: 方法的名字用一个小写字母开头,后面的单词用大写字母开头,例如:run(),getBalance()。

        staticfinal变量的命名: static final变量的名字所有字母都大写,并且能表示完整含义。例如:PI,PASSWORD。

        参数的命名: 参数的名字和变量的命名规范一致。

        数组的命名: 数组应该总是用这样的方式来命名:byte[] buffer。

        Java 标识符

        Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

        关于 Java 标识符,有以下几点需要注意:

        所有的标识符都应该以字母(A-Z 或者 a-z),美元符($)、或者下划线(_)开始
        首字符之后可以是字母(A-Z 或者 a-z),美元符($)、下划线(_)或数字的任何字符组合
        关键字不能用作标识符
        标识符是大小写敏感的
        合法标识符举例:age、$salary、_value、__1_value
        非法标识符举例:123abc、-salary

        标识符可以用来标识变量名、类名、类中的方法名和文件名等。

        命名规则:

        (1) 由字母、数字、下划线、$组成,不能以数字开头。
        (2) 大小写敏感。
        (3) 不得使用java中的关键字和保留字。

        关键字:都是小写的,jdk1.2多了strictfp(经准浮点型),关键字 jdk1.4多了assert(断言)关键字,jdk1.5多了enum(枚举) 关键字。

        true、false、null 严格说不应该算关键字,应称其为保留字更合适。

        习惯:

        (1) 标识符要符合语义信息。
        (2) 包名所有字母小写。
        (3) 类名每个单词首字母大写,其它小写,如:TarenaStudent。
        (4) 变量和方法:第一个单词小写,从第二个单词开始首字母大写,如:tarenaStudent。
        (5) 常量:所有字母大写,每个单词之间用 _ 连接。

        常用的转义字符:

        "\b"                     (退格)
        "\f"                     (换页)
        "\n"                     (换行)
        "\r"                     (回车)
        "\t"                     (水平制表符(到下一个tab位置))
        "\' "                     (单引号)
        "\" "                     (双引号)
        "\\"                     (反斜杠)

        Java修饰符

        像其他语言一样,Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符:

        访问控制修饰符 : default, public , protected, private
        非访问控制修饰符 : final, abstract, static, synchronized
     
        修饰符用来定义类、方法或者变量,通常放在语句的最前端。我们通过下面的例子来说明:
        public class ClassName {
        // ...
        }
        private boolean myFlag;
        static final double weeks = 9.5;
        protected static final int BOXWIDTH = 42;
        public static void main(String[] arguments) {
       // 方法体
        }


        访问控制修饰符

        Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

        default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。

        private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

        public : 对所有类可见。使用对象:类、接口、变量、方法

        protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。

        我们可以通过以下表来说明访问权限:
                                                                    访问控制    
        修饰符          当前类         同一包内            子孙类(同一包)               子孙类(不同包)                 其他包
            public         Y                     Y                         Y                                     Y                                     Y
            protected     Y                     Y                         Y                                     Y/N(说明)                     N
            default         Y                     Y                         Y                                     N                                     N
            private         Y                     N                         N                                     N                                     N
        


        默认访问修饰符-不使用任何关键字

        使用默认访问修饰符声明的变量和方法,对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

        如下例所示,变量和方法的声明可以不使用任何修饰符。
        实例
        String version = "1.5.1";
        boolean processOrder() {
       return true;
    }


        私有访问修饰符-private

        私有访问修饰符是最严格的访问级别,所以被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private。

        声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

        Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

        下面的类使用了私有访问修饰符:
        public class Logger {
       private String format;
       public String getFormat() {
          return this.format;
       }
       public void setFormat(String format) {
          this.format = format;
       }
    }

        实例中,Logger 类中的 format 变量为私有变量,所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量,定义了两个 public 方法:getFormat() (返回 format的值)和 setFormat(String)(设置 format 的值)
        公有访问修饰符-public

        被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

        如果几个相互访问的 public 类分布在不同的包中,则需要导入相应 public 类所在的包。由于类的继承性,类所有的公有方法和变量都能被其子类继承。

        以下函数使用了公有访问控制:
        public static void main(String[] arguments) {
       // ...
    }

        Java 程序的 main() 方法必须设置成公有的,否则,Java 解释器将不能运行该类。
        受保护的访问修饰符-protected

        protected 需要从以下两个点来分析说明:

        子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;

        子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。

        protected 可以修饰数据成员,构造方法,方法成员,不能修饰类(内部类除外)。

        接口及接口的成员变量和成员方法不能声明为 protected。 可以看看下图演示:

        子类能访问 protected 修饰符声明的方法和变量,这样就能保护不相关的类使用这些方法和变量。

        下面的父类使用了 protected 访问修饰符,子类重写了父类的 openSpeaker() 方法。
        class AudioPlayer {
       protected boolean openSpeaker(Speaker sp) {
          // 实现细节
       }
    }
     
        class StreamingAudioPlayer extends AudioPlayer {
       protected boolean openSpeaker(Speaker sp) {
          // 实现细节
       }
    }

        如果把 openSpeaker() 方法声明为 private,那么除了 AudioPlayer 之外的类将不能访问该方法。

        如果把 openSpeaker() 声明为 public,那么所有的类都能够访问该方法。

        如果我们只想让该方法对其所在类的子类可见,则将该方法声明为 protected。

        protected 是最难理解的一种 Java 类成员访问权限修饰词,更多详细内容请查看 Java protected 关键字详解。

        访问控制和继承

        请注意以下方法继承的规则:

        父类中声明为 public 的方法在子类中也必须为 public。

        父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。

        父类中声明为 private 的方法,不能够被继承。
        


        非访问修饰符

        为了实现一些其他的功能,Java 也提供了许多非访问修饰符。

        static 修饰符,用来修饰类方法和类变量。

        final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。

        abstract 修饰符,用来创建抽象类和抽象方法。

        synchronized 和 volatile 修饰符,主要用于线程的编程。
        


        static 修饰符

        静态变量:

        static 关键字用来声明独立于对象的静态变量,无论一个类实例化多少对象,它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

        静态方法:

        static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据,然后计算这些数据。

        对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

        如下例所示,static修饰符用来创建类方法和类变量。
        public class InstanceCounter {
       private static int numInstances = 0;
       protected static int getCount() {
          return numInstances;
       }
     
       private static void addInstance() {
          numInstances++;
       }
     
       InstanceCounter() {
          InstanceCounter.addInstance();
       }
     
       public static void main(String[] arguments) {
          System.out.println("Starting with " +
          InstanceCounter.getCount() + " instances");
          for (int i = 0; i < 500; ++i){
             new InstanceCounter();
              }
          System.out.println("Created " +
          InstanceCounter.getCount() + " instances");
       }
    }

        以上实例运行编辑结果如下:

        Starting with 0 instances
        Created 500 instances

        final 修饰符

        final 变量:

        final 表示"最后的、最终的"含义,变量一旦赋值后,不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

        final 修饰符通常和 static 修饰符一起使用来创建类常量。
        实例
        public class Test{
      final int value = 10;
      // 下面是声明常量的实例
      public static final int BOXWIDTH = 6;
      static final String TITLE = "Manager";
     
      public void changeValue(){
         value = 12; //将输出一个错误
      }
    }

        final 方法

        类中的 final 方法可以被子类继承,但是不能被子类修改。

        声明 final 方法的主要目的是防止该方法的内容被修改。

        如下所示,使用 final 修饰符声明方法。
        public class Test{
        public final void changeName(){
           // 方法体
        }
    }

            final 类

        final 类不能被继承,没有类能够继承 final 类的任何特性。
        实例
    public final class Test {
       // 类体
    }

        abstract 修饰符

        抽象类:

        抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。

        一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法,那么该类一定要声明为抽象类,否则将出现编译错误。

        抽象类可以包含抽象方法和非抽象方法。
        实例
    abstract class Caravan{
       private double price;
       private String model;
       private String year;
       public abstract void goFast(); //抽象方法
       public abstract void changeColor();
    }

        抽象方法

        抽象方法是一种没有任何实现的方法,该方法的的具体实现由子类提供。

        抽象方法不能被声明成 final 和 static。

        任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。

        如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

        抽象方法的声明以分号结尾,例如:public abstract sample();。
        实例
    public abstract class SuperClass{
        abstract void m(); //抽象方法
    }
     
    class SubClass extends SuperClass{
         //实现抽象方法
          void m(){
              .........
          }
    }
        synchronized 修饰符

        synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
        实例
        public synchronized void showDetails(){
    .......
    }


        
        transient 修饰符

        序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。
        
        该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型。
        实例
        public transient int limit = 55;   // 不会持久化
        public int b; // 持久化
        volatile 修饰符

        volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。

        一个 volatile 对象引用可能是 null。
        实例
    public class MyRunnable implements Runnable
    {
        private volatile boolean active;
        public void run()
        {
            active = true;
            while (active) // 第一行
            {
                // 代码
            }
        }
        public void stop()
        {
            active = false; // 第二行
        }
    }

        通常情况下,在一个线程调用 run() 方法(在 Runnable 开启的线程),在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用,那么在 第二行 的 active 值为 false 时循环不会停止。

        但是以上代码中我们使用了 volatile 修饰 active,所以该循环会停止。

     

        Java 变量


        Java 中主要有如下几种类型的变量

        局部变量

            Java 局部变量

            局部变量声明在方法、构造方法或者语句块中;
            局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
            访问修饰符不能用于局部变量;
            局部变量只在声明它的方法、构造方法或者语句块中可见;
            局部变量是在栈上分配的。
            局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。

            实例 1

            在以下实例中age是一个局部变量。定义在pupAge()方法中,它的作用域就限制在这个方法中。
            package com.runoob.test;
     
            public class Test{
            public void pupAge(){
            int age = 0;
                age = age + 7;
                System.out.println("小狗的年龄是: " + age);
       }
       
            public static void main(String[] args){
                Test test = new Test();
                test.pupAge();
       }
    }

            以上实例编译运行结果如下:

            小狗的年龄是: 7

            实例 2

            在下面的例子中 age 变量没有初始化,所以在编译时会出错:
            package com.runoob.test;
     
            public class Test{
            public void pupAge(){
            int age;
            age = age + 7;
            System.out.println("小狗的年龄是 : " + age);
       }
       
            public static void main(String[] args){
            Test test = new Test();
            test.pupAge();
       }
    }

            以上实例编译运行结果如下:

            Test.java:4:variable number might not have been initialized
            age = age + 7;
             ^
                1 error
        


            类变量(静态变量)

            类变量也称为静态变量,在类中以 static 关键字声明,但必须在方法之外。
            无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。
            静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变。
            静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。
            静态变量在第一次被访问时创建,在程序结束时销毁。
            与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。
            默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。
            静态变量可以通过:ClassName.VariableName的方式访问。
            类变量被声明为public static final类型时,类变量名称一般建议使用大写字母。如果静态变量不是public和final类型,其命名方式与实例变量以及局部变量的命名方式一致。

            实例:
            Employee.java 文件代码:
            import java.io.*;
     
        public class Employee {
        //salary是静态的私有变量
        private static double salary;
        // DEPARTMENT是一个常量
        public static final String DEPARTMENT = "开发人员";
        public static void main(String[] args){
        salary = 10000;
            System.out.println(DEPARTMENT+"平均工资:"+salary);
        }
    }

            以上实例编译运行结果如下:

            开发人员平均工资:10000.0

            注意:如果其他类想要访问该变量,可以这样访问:Employee.DEPARTMENT。

        成员变量(非静态变量)

        实例变量

        实例变量声明在一个类中,但在方法、构造方法和语句块之外;
        当一个对象被实例化之后,每个实例变量的值就跟着确定;
        实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
        实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;
        实例变量可以声明在使用前或者使用后;
        访问修饰符可以修饰实例变量;
        实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;
        实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;
        实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。

        实例
        Employee.java 文件代码:
        import java.io.*;
        public class Employee{
       // 这个实例变量对子类可见
       public String name;
       // 私有变量,仅在该类可见
       private double salary;
       //在构造器中对name赋值
       public Employee (String empName){
          name = empName;
       }
       //设定salary的值
       public void setSalary(double empSal){
          salary = empSal;
       }  
       // 打印信息
       public void printEmp(){
          System.out.println("名字 : " + name );
          System.out.println("薪水 : " + salary);
       }
     
       public static void main(String[] args){
          Employee empOne = new Employee("RUNOOB");
          empOne.setSalary(1000);
          empOne.printEmp();
       }
    }

        以上实例编译运行结果如下:

        $ javac Employee.java
        $ java Employee
        名字 : RUNOOB
        薪水 : 1000.0

    成员变量、局部变量、静态变量的区别

                         成员变量                    局部变量                                      静态变量

    定义位置        在类中,方法外          方法中,或者方法的形式参数         在类中,方法外

    初始化值        有默认初始化值        无,先定义,赋值后才能使用           有默认初始化值

    调用方式         对象调用                  ---------------                                   对象调用,类名调用

    存储位置         堆中                        栈中                                               方法区

    生命周期         与对象共存亡          与方法共存亡                                与类共存亡

    别名                实例变量                 ---------------                                    类变量

      

     Java 数组


        
        数组是储存在堆上的对象,可以保存多个同类型变量。在后面的章节中,我们将会学到如何声明、构造以及初始化一个数组。
        Java 枚举

        Java 5.0引入了枚举,枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的 bug。

        例如,我们为果汁店设计一个程序,它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。
        实例
    class FreshJuice {
       enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }
       FreshJuiceSize size;
    }
     
    public class FreshJuiceTest {
       public static void main(String []args){
          FreshJuice juice = new FreshJuice();
          juice.size = FreshJuice.FreshJuiceSize.MEDIUM  ;
       }
    }

        注意:枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。
        
        一个完整的Java。源程序应该包括下列部分:

         package语句,该部分至多只有一句,必须放在源程序的第一句。
         import语句,该部分可以有若干import语句或者没有,必须放在所有的类定义之前。
         public classDefinition,公共类定义部分,至多只有一个公共类的定义,Java语言规定该Java源程序的文件名必须与该公共类名完全一致。
         classDefinition,类定义部分,可以有0个或者多个类定义。
        interfaceDefinition,接口定义部分,可以有0个或者多个接口定义。

        例如:

        package javawork.helloworld;
        /*把编译生成的所有.class文件放到包javawork.helloworld中*/
        import java awt.*;
        //告诉编译器本程序中用到系统的AWT包
        import javawork.newcentury;
        /*告诉编译器本程序中用到用户自定义的包javawork.newcentury*/
        public class HelloWorldApp{...}
        /*公共类HelloWorldApp的定义,名字与文件名相同*/
        class TheFirstClass{...};
        //第一个普通类TheFirstClass的定义
        interface TheFirstInterface{......}
        /*定义一个接口TheFirstInterface*/

        package语句:由于Java编译器为每个类生成一个字节码文件,且文件名与类名相同因此同名的类有可能发生冲突。为了解决这一问题,Java提供包来管理类名空间,包实 提供了一种命名机制和可见性限制机制。

        Java注释

        类似于 C/C++、Java 也支持单行以及多行注释。注释中的字符将被 Java 编译器忽略。
    public class HelloWorld {
       /* 这是第一个Java程序
        *它将打印Hello World
        * 这是一个多行注释的示例
        */
        public static void main(String []args){
           // 这是单行注释的示例
           /* 这个也是单行注释的示例 */
           System.out.println("Hello World");
        }
    }

        注释规范

        1、类注释

        在每个类前面必须加上类注释,注释模板如下:

    /**
    * Copyright (C), 2006-2010, ChengDu Lovo info. Co., Ltd.
    * FileName: Test.java
    * 类的详细说明
    *
    * @author 类创建者姓名
    * @Date    创建日期
    * @version 1.00
    */

        2、属性注释

        在每个属性前面必须加上属性注释,注释模板如下:

        /** 提示信息 */
        private String strMsg = null;

        3、方法注释

        在每个方法前面必须加上方法注释,注释模板如下:

    /**
    * 类方法的详细使用说明
    *
    * @param 参数1 参数1的使用说明
    * @return 返回结果的说明
    * @throws 异常类型.错误代码 注明从此类方法中抛出异常的说明
    */

        4、构造方法注释

        在每个构造方法前面必须加上注释,注释模板如下:

    /**
    * 构造方法的详细使用说明
    *
    * @param 参数1 参数1的使用说明
    * @throws 异常类型.错误代码 注明从此类方法中抛出异常的说明
    */

        5、方法内部注释


        
        在方法内部使用单行或者多行注释,该注释根据实际情况添加。

        如:

        //背景颜色
        Color bgColor = Color.RED

        Java 空行

        空白行或者有注释的行,Java 编译器都会忽略掉。

        继承

        在 Java 中,一个类可以由其他类派生。如果你要创建一个类,而且已经存在一个类具有你所需要的属性或方法,那么你可以将新创建的类继承该类。

        利用继承的方法,可以重用已存在类的方法和属性,而不用重写这些代码。被继承的类称为超类(super class),派生类称为子类(subclass)。

        接口

        在 Java 中,接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。

        接口只定义派生要用到的方法,但是方法的具体实现完全取决于派生类。
     
     

     

    展开全文
  • 熟练使用函数的调用等 正则表达式:熟练舒勇re模块的各种方法 数据库:关系型数据库、非关系型数据库、MySQL Python语法进阶:闭包、装饰器、生成器、迭代器 mini-web服务器:根据网络服务的过程写出简易的web服务器...

    第一阶段、Python基础

    知识点:

    计算机组成原理:计算机组成部分、操作系统分类、B/S和C/S架构、理解软件与硬件的区别

    Python变量以及开发环境:字符串、数字、字典、列表、元祖等

    流程控制语句:程序的执行顺序,顺序执行、循环执行、选择执行

    函数:定义函数、调用函数、函数的嵌套、递归函数

    文件的基本操作:文件的打开、编辑、关闭

    面向对象编程:类对象、实例对象、定义类、实例化对象

    异常处理:学会捕捉异常、自定义异常

    模块和包:理解模块和包的概念并学会使用

    飞机大战游戏制作:自己独立完成飞机大战游戏

    第二阶段、Python和Linux高级

    知识点:

    Linux系统应用:Linux发行版系统的使用、基本的操作语句

    网络编程:TCP/IP协议、服务器工作过程

    并发编程:线程、进程、协程

    函数高级应用:熟练使用函数的调用等

    正则表达式:熟练舒勇re模块的各种方法

    数据库:关系型数据库、非关系型数据库、MySQL

    Python语法进阶:闭包、装饰器、生成器、迭代器

    mini-web服务器:根据网络服务的过程写出简易的web服务器

    mini-web框架:可以编写简易的web服务器框架

    第三阶段:前端开发

    知识点

    HTML的学习:HTML的文档结构、快速创建HTML方法

    CSS:CSS的使用

    PS的简单应用:Photoshop的基本使用、取色、图层

    JavaScript的学习:JavaScript的基本语法

    jQuery的学习:jQuery的使用

    Vue框架:框架的使用以及注意点

    第四阶段:Web开发

    Flask web框架的使用:模板与表单、数据库的使用、单元测试、第三方扩展与部署、Redis缓存使用、GIT版本控制、云服务器的使用、验证码的收发、网站项目开发实战

    Django web框架的使用:框架的使用方法、模型介绍、ORM以及数据库操作、视图以及模板、Django中间件、Django REST Framework、网站项目开发实战

    第五阶段:爬虫开发

    知识点:

    爬虫开发的知识体系与相关工具:网络爬虫的原理以及相关爬虫工具

    MongoDB数据库:数据库的增删改查

    Scrapy框架:框架的原理以及使用

    定制化爬虫采集系统:数据的采集、分析

    展开全文
  • 很多人想要Python,但面对繁杂却又众多的基础语法难免会觉得枯燥,接下来小编就给大家梳理一下Python基础语法知识。 1、常用列表的操作 L = [[1, 2], 'string', {}] # 嵌套列表 L = list('spam') # 列表初始化 L ....

      Python基础语法知识有哪些?怎么高效率去学习?Python语法简单、功能强大,是人工智能时代最佳的编程语言。很多人想要学Python,但面对繁杂却又众多的基础语法难免会觉得枯燥,接下来小编就给大家梳理一下Python基础语法知识。

    f20de4da8d9a26c3ea42cd68ce0c08b2.png

      1、常用列表的操作

      L = [[1, 2], 'string', {}] # 嵌套列表

      L = list('spam') # 列表初始化

      L = list(range(0, 4)) # 列表初始化

      list(map(ord, 'spam')) # 列表解析

      len(L) # 求列表长度

      L.count(value) # 求列表中某个值的个数

      L.append(obj) # 向列表的尾部添加数据,比如append(2),添加元素2

      L.insert(index, obj) # 向列表的指定index位置添加数据,index及其之后的数据后移

      L.extend(interable) # 通过添加iterable中的元素来扩展列表,比如extend([2]),添加元素2,注意和append的区别

      L.index(value, [start, [stop]]) # 返回列表中值value的第一个索引

      L.pop([index]) # 删除并返回index处的元素,默认为删除并返回最后一个元素

      L.remove(value) # 删除列表中的value值,只删除第一次出现的value的值

      L.reverse() # 反转列表

      L.sort(cmp=None, key=None, reverse=False) # 排序列表

      2、文件基本操作

      output = open(r'C:spam', 'w') # 打开输出文件,用于写

      input = open('data', 'r') # 打开输入文件,用于读。打开的方式可以为'w', 'r', 'a', 'wb', 'rb', 'ab'等

      fp.read([size]) # size为读取的长度,以byte为单位

      fp.readline([size]) # 读一行,如果定义了size,有可能返回的只是一行的一部分

      fp.readlines([size]) # 把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长。

      fp.readable() # 是否可读

      fp.write(str) # 把str写到文件中,write()并不会在str后加上一个换行符

      fp.writelines(seq) # 把seq的内容全部写到文件中(多行一次性写入)

      fp.writeable() # 是否可写

      fp.close() # 关闭文件。

      fp.flush() # 把缓冲区的内容写入硬盘

      fp.tell() # 返回文件操作标记的当前位置,以文件的开头为原点

      fp.next() # 返回下一行,并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。

      fp.seek(offset[, whence]) # 将文件打操作标记移到offset的位置。whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。

      fp.seekable() # 是否可以seek

      fp.truncate([size]) # 把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。

      3、Python的while语句或者for语句可以带else语句,也可以带continue/break/pass语句

      while a > 1:

      anything

      else:

      anything

      # else语句会在循环结束后执行,除非在循环中执行了break,同样的还有for语句

      for i in range(5):

      anything

      else:

      anything

      4、匿名函数:lambda

      f = lambda x, y, z: x + y + z # 普通匿名函数,使用方法f(1, 2, 3)

      f = lambda x=1, y=1: x + y # 带默认参数的lambda函数

      def action(x): # 嵌套lambda函数

      return (lambda y: x + y)

      f = lambda: a if xxx() else b # 无参数的lambda函数,使用方法f()

      5、生成器函数:yield VS return

      def gensquare(N):

      for i in range(N):

      yield i ** 2 # 状态挂起 可以恢复到此时的状态

      for i in gensquare(5): # 使用方法

      print(i, end=' ') # [0, 1, 4, 9, 16]

      x = gensquare(2) # x是一个生成对象

      next(x) # 等同于x.__next__() 返回0

      next(x) # 等同于x.__next__() 返回1

      next(x) # 等同于x.__next__() 抛出异常StopIteration

      掌握Python语法才能更好的学习接下来的知识点,想要成为一个优秀的Python人才,你一定要注意理论与实战兼备。你可以进行专业高效率的学习,让自己从入学到就业,更快拿获高薪!

    展开全文
  • MySQL语法错误求助 java中需要调用存储过程,但是在通过Navicat for MySQL创建存储过程时除了问题,求助各位大佬指点一下,语法错误究竟是啥? ps:java只学习玩基本的类之后,老师跨度非常大,几天时间到了jdbc,...
  • 很多人想要Python,但面对繁杂却又众多的基础语法难免会觉得枯燥,接下来小编就给大家梳理一下Python基础语法知识。  1、常用列表的操作  L = [[1, 2], 'string', {}] # 嵌套列表  L = list('spam') # ...
  • 很多人想要Python,但面对繁杂却又众多的基础语法难免会觉得枯燥,接下来小编就给大家梳理一下Python基础语法知识。1、常用列表的操作L = [[1, 2], 'string', {}] # 嵌套列表L = list('spam') # 列表初始化L = ...
  • 学完C语言语法后我不知道该怎么学了。但是我自己有两种方法。 第一是:做练习,C语言趣味程序百例精解的题目。 第二是:学习数据结构。 我不知道该用哪种方法的好,目前我主要是针对C语言而不是像进阶去学习...
  • 初中开始就会慢慢学习比较难的英语语法了,很多孩子突然就接触难度较大一点的语法时,就会感觉很疲惫,比如名词的语法看似简单,但其实很多孩子还是搞明白单复数的一些变化,今天我总结了名词的语法知识,希望对大家...
  • 用思维导图学语法

    千次阅读 2016-08-07 12:20:03
    最近我一直在想,怎么样才能把书中别人的东西变成自己...借着学语法的机会,我想试试思维导图这种语言方式。 语法是基础的,是一门语言的基础运行规则,想要玩儿转一样东西,就先得摸清这个圈子的游戏规则。我买回了一
  • 很多人想要Python,但面对繁杂却又众多的基础语法难免会觉得枯燥,接下来小编就给大家梳理一下Python基础语法知识。 1、常用列表的操作 L = [[1, 2], 'string', {}] # 嵌套列表 L = list('spam') # 列表初始化...
  • 利用顺口溜来学习英语,至少有三大...英语语法的叙述,讲究科学性,追求严谨。故而学生看起来,不免有些枯燥,看不下去。为此,全国各地的名师们编写了不少英语语法口诀,以帮助记忆。收集起来,大致有20首。01英语...
  • 本人在上学,上完c++课后,自己也自学了一点,c++的基本语法还算熟悉,现在在学MFC,但是看别人的MFC代码感觉好迷茫,一点点还是看得懂,代码一长就一团糟,求问怎么继续学习,谢谢
  • Python语言及应用课程内容:Python语言基础,面向对象设计,多线程编程,数据库交互技术,前端特效,Web框架,爬虫框架,网络编程掌握技能:(1)掌握Python语言语法及面向对象设计;(2)掌握Python多线程并发编程技术...
  • Python学习:基本语法

    2020-12-22 07:47:33
    基本语法 1.首先,在Python中,严格区分大小写。我们先在python中输出一个hello。 格式:print(‘内容’) 当把小p换成大p的时候,就会出现报错 下面有个Traceback,其意思是回溯,每当你出现错误的时候,他就会...
  • Markdown基础语法学习

    2020-12-22 11:32:22
    Markdown基础语法 标题 写文章怎么能没有标题~ 通过# 加内容的方式定义一个标题,注意井号与文字之间有一个空格,几个井号就代表几级。 一级标题 # 一级标题 二级标题 ## 二级标题 三级标题 ### 三级标题 四级标题 #...
  • 为了方便快速的抓取或者过滤感兴趣的报文内容,从本次开始我们介绍抓包的过滤语法。Wireshark采用了BPF语法进行数据包过滤,可以分为抓取之前过滤和对已抓取的数据包进行过滤。不同点为:抓取之前过滤,wireshark会...
  • Python基础语法学习14

    2020-09-10 11:44:48
    基础语法学习Day14异常捕获异常捕获1.什么是异常2.什么是异常捕获3.怎么捕获异常4.finally继承1.什么是继承2.继承的语法给子类添加属性和方法1.添加属性和方法2.类中方法的调用过程自定义异常类型和抛出异常1.抛出...
  • Python基础语法学习3

    2020-07-23 20:42:45
    基础语法学习Day3if语句什么时候使用if语句怎么使用if语句if单分支结构if双分支结构if多分支结构python中的三目运算符for循环for循环range函数while循环continue,break,elsecontinuebreakelse if语句 什么时候使用...
  • 高中英语语法学习方法总结 语法是词汇组成语言的基本规则,但很多学生语法学得不怎么样,下面是整理的高中英语语法学习方法总结,希望大家喜欢。 1.观察感悟 高中生学习英语语法要重视“观察与感悟”。观察的内容...
  • smali 语法学习历程

    千次阅读 2014-04-20 16:51:36
    怎么学习smali呢?最好的学习方法某过于写一个能跑的Hello world 出来,那样既可以检测学习效果,又可以
  • 首先,Python应用方面很广,在web领域也很成熟,有很多知名的互联网公司也是用Python开发,比如知乎,果壳,豆瓣等……正如我们所知道的,Python语言代码优雅,语法干净简单,容易学习,对初学者很友好。在爬虫方向...
  • SQL语法学习20170803

    2017-08-03 16:59:35
    一直我都觉得自己的SQL语言学习的不错,但是很多年不再使用以后,突然发现,其实还是有很多的知识点不知道怎么使用的,一直以来都不是以应用进行学习和促进,大多数时候都是觉得自己会了,其实当事情发展为以问题为...
  • Python基础语法学习15

    2020-09-10 14:33:12
    基础语法学习Day15文件基本操作1.文件操作2.文件操作基本步骤文件域数据持久化1.数据持久化2.什么时候需要做数据持久化3.怎么做持久化CSV文件的操作1.什么是CSV文件2.Python中怎么操作CSV文件CSV文件的读操作json...
  • jq基础语法学习1

    2020-08-26 20:44:36
    基础语法学习1认识jQueryjQuery的DOM操作jQuery属性操作事件绑定Ajax网络请求 认识jQuery 什么是jQuery jQuery是使用js封装的一个库,本质就是一个js文件。 通过jQuery类的对象来提供功能,能够让DOM操作变得很简单...
  • js基础语法学习1

    2020-08-19 20:00:57
    基础语法学习1认识js什么是jsjs代码写在哪js用来干什么js怎么写变量,运算符定义变量四种定义变量的方法四种方法的区别同时定义多个变量运算符分支,循环分支结构循环函数函数的定义函数的调用arguments匿名函数箭头...
  • 写过 Web 程序的都对 include 包含文件很熟悉,那么在 Django,include 又是怎么一个机制呢?下面这篇文章主要给大家介绍了关于django模板语法学习之include的相关资料,需要的朋友可以参考借鉴,下面随着小编来一起...
  • CSS基础语法学习1

    2020-08-14 20:03:06
    基础语法学习CSS基础什么是CSS(样式表)CSS代码写在哪CSS怎么写选择器常用 CSS基础 什么是CSS(样式表) CSS – 层叠样式表 CSS是web标准中的表现标准,主要用来设置网页内容的样式和布局 CSS代码写在哪 内联样式表:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,018
精华内容 1,607
关键字:

怎么学语法