精华内容
下载资源
问答
  • 本文章由公号【开发小鸽】发布!欢迎关注!!! 老规矩–妹妹镇楼: 一. 注解 (一) 概述 ...一代码级别的说明。它是JDK1.5及以后版本引入的一个特性,与类、接口、...(三) 注解的作用 1. 编写文档   &nb

    本文章由公号【开发小鸽】发布!欢迎关注!!!


    老规矩–妹妹镇楼:

    一. 注解

    (一) 概述

            也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性,与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面,用来对这些元素进行说明,注释。

    (二) 使用方法

            @注解名称

    (三) 注解的作用

    1. 编写文档

            通过代码里标识的注解生成文档。

    2. 代码分析

            通过代码里标识的注解对代码进行分析

    3. 编译检查

            通过代码里标识的注解让编译器能够实现基本的编译检查(如@Override)


    二.JDK内置注解

    1. @Override

            检测该注解标注的方法是否是继承自父类的。

    2. @Deprecated

            表示该注解标注的内容已经过时了,可以用但是不建议使用。

    3. @SuppressWarnings

            抑制警告,抑制已经显示的警告。一般传递参数all

    @SuppressWarnings(“all”)
    

    三 自定义注解

    (一) 格式

    元注解
    public @interface 注解名称{}
    

    (二) 注解的本质

            注解本质上是一个接口,改接口默认继承Annotation接口

    (三) 注解的属性

            注解中的属性即接口中的抽象方法,属性的返回值类型只能用以下的类型:

    1. 基本数据类型
    2. String
    3. 枚举
    4. 注解
    5. 以上类型的数组

            定义了属性后,在使用注解时需要给属性赋值。即给抽象方法的返回值赋值。

    注意:
            如果使用default关键字给属性默认初始化值,则使用注解时可以不赋值属性。
            如果只有一个属性要赋值,该属性名称为value,则value可省略直接定义值。


    四.元注解

    (一)概述

            预定义的注解,用于描述注解的注解。

    (二)举例

    1. @Target

            用于描述注解能够作用的位置

    TYPE:作用于类上
    METHOD:作用于方法上
    FIELD:作用于成员变量上
    

    2.@Retention

            描述注解被保留的阶段,三个阶段:源代码夹断,Class类阶段,运行阶段。

    @Retention(RetentionPolicy.SOURCE)
    @Retention(RetentionPolicy.CLASS)
    @Retention(RetentionPolicy.RUNTIME)
    

    3. @Documented

            描述注解是否被抽取到api文档中显示。

    4. @Inherited

            描述注解是否被子类继承


    五.注解的使用

            注解通常用于取代配置文件,通过解析注解即可获取注解中定义的属性。

    (一) 定义注解:

    @Target({Element.Type.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Pro{
    	String className();
    	String methodName();
    }
    

    (二) 定义类

    @Pro(className = “xx.xx”, methodName = “xx”)
    public static class ReTest{}
    

            我们要在ReTest类中利用注解取得相应的className和methodName,需要通过以下的步骤来获取。

    1. 解析注解

            获取该类的字节码文件对象

    Class<ReTest> ret = ReTest.class;
    

    2. 获取注解定义位置的对象

            获取注解对象就是在内存中生成了该注解接口的子类实现对象。

    Pro an = ret.getAnnotation(Pro.class)
    

    3. 调用注解对象中定义的抽象方法,获取返回值

    String className = an.className();
    String methodName = an.methodName();
    

    六.注解用于搭建简单的测试框架

    (一)需求

            将注解加于方法之上,即可测试该方法是否会出现异常,并将异常记录在文件中。

    (二)代码

            测试计算器类Calculator中的方法是有会出现异常,将@Check注解放置于方法上,有注解的方法被测试类TestCheck测试,测试结果放在bug.txt文本文件中。

    每个文件的代码如下:

    1. 计算器类Calculator

    package 注解实现测试框架;
    
    public class Calculator {
        //加法
        @Check
        public void add(){
            System.out.println("1 + 0 =" + (1 + 0));
        }
    
        //减法
        @Check
        public void sub(){
            System.out.println("1- 0 = " + (1-0));
        }
    
        //除法
        @Check
        public void div(){
            System.out.println("1 / 0 = " + (1 / 0));
        }
    }
    

    2.自定义注解@Check


    package 注解实现测试框架;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface Check {
    
    }
    

    3.测试类


    package 注解实现测试框架;
    
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    public class TestCheck {
        public static void main(String[] args) throws IOException {
            Calculator c = new Calculator();
            //获取该类的字节码文件对象
            Class<? extends Calculator> cls = c.getClass();
            //获取所有方法
            Method[] methods = cls.getMethods();
    
            int num = 0;
            BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));
    
            for(Method method : methods){
                //判断方法上是否有Check注解
                if(method.isAnnotationPresent(Check.class)){
                    //有Check注解,执行
                    try{
                        method.invoke(c);
                    } catch (Exception e) {
                        //捕获异常,记录到文件中
    
                        num++;
                        bw.write(method.getName() + "方法出现异常");
                        bw.newLine();
                        bw.write("异常的名称:" + e.getCause());
                        bw.newLine();
                        bw.write("异常的原因:" + e.getMessage());
                        bw.newLine();
                        bw.write("----------------");
                        bw.newLine();
                    }
                }
            }
    
            bw.write("本次测试一共出现" + num + "次异常");
    
            bw.flush();
            bw.close();
    
        }
    }
    
    展开全文
  • 设计模式【PDF版】

    热门讨论 2011-05-30 14:13:49
    主要是介绍各种格式流行软件设计模式,对于程序员进一步提升起推进作用,有时间可以随便翻翻~~ 23设计模式汇集 如果你还不了解设计模式是什么话? 那就先看设计模式引言 ! 学习 GoF 设计模式重要性 ...
  • 第十章 三角和在数论中的作用 §1. 格点与三角和 §2. 同余式的解数与三角和 §3. 丟番图方程的解数与三角和 第一章 有理型三角和 §1. 有理型三角和的平均值 §2. Mordell的结果 §3. Mordell结果的n维推广 §4. ...
  • 本文通过实例说明了一数学方法和该方法的算法,并讨论了该算法的执行时间,从而获得了Galois域GF(pq)上的单项IP。 该方法与在Galois字段GF(pq)上的两个多项式的多项式乘法非常相似,但是执行上有所不同。 ...
  • (1)分析电路中各元件的作用; (2)解放大电路的放大原理; (3)能分析计算电路的静态工作点; (4)理解静态工作点的设置目的和方法。 以上四项中,最后一项较为重要。 偏置电阻的计算图1中,C1,C2为...
  • php高级开发教程说明

    2008-11-27 11:39:22
    前面提到每一语言代表一解决问题特定方法,这些问题多属于具有特殊要求某 一特殊种类。因为这些语言集中在一个有限应用领域内,他们成功性也限制在这些领域。 像C和P a s c a l这样语言变得如此流行...
  • 概述 Java 注解(Annotation)又称 Java 标注,是 ...它可以声明在包、类、字段、方法、局部变量、方法参数等前面,用来对这些元素进行说明,注释。 作用分类: 编写文档:通过代码里标识元数据生成文档【doc...
    概述
    • Java 注解(Annotation)又称 Java 标注,是 JDK5.0 引入的一种注释机制。
    • 注解(Annotation),也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性,与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面,用来对这些元素进行说明,注释。
    • 作用分类:
    1. 编写文档:通过代码里标识的元数据生成文档【doc文档】
    2. 代码分析:通过代码里标识的元数据对代码进行分析【使用反射】
    3. 编译检查:通过代码里标识的元数据让编译器能够实现基本的编译检查【Override】
    • 使用:@注解名称
    JDK中内置的注解
    • @Override,作用是对覆盖超类中方法的方法进行标记,如果被标记的方法并没有实际覆盖超类中的方法,则编译器会发出错误警告。
    • @Deprecated,作用是对不应该再使用的方法添加注解,当编程人员使用这些方法时,将会在编译时显示提示信息,它与javadoc里的@deprecated标记有相同的功能,准确的说,它还不如javadoc @deprecated,因为它不支持参数,
    • @SuppressWarnings,作用式用来压制警告
      其参数有:
      deprecation,使用了过时的类或方法时的警告
      unchecked,执行了未检查的转换时的警告
      fallthrough,当 switch 程序块直接通往下一种情况而没有 break 时的警告
      path,在类路径、源文件路径等中有不存在的路径时的警告
      serial,当在可序列化的类上缺少serialVersionUID 定义时的警告
      finally ,任何 finally 子句不能正常完成时的警告
      all,关于以上所有情况的警告
      
    自定义注解
    • 格式:
      • 元注解:public @interface 注解名称{}
      public @interface MyAnno {
      }
      
    • 本质:就是一个接口,默认继承java.lang.annotation.Annotation
      public interface MyAma extends java.lang.annotation.Annotation {
      }
      
    • 属性:接口里面定义的抽象方法
      • 属性的返回值类型:基本数据类型,String,枚举、注解,前几种类型的数组
      • 定义了属性,在使用时需要给属性赋值。如果定义属性时,使用default关键字给属性初始化值,使用注解时可以不进行赋值。如果只有一个属性需要赋值,并且属性的名称是value,那么value可以省略,直接写值即可。如果数组赋值,值使用{}包裹。如果数组中只有一个值,则{}可以省略
    • 元注解:用于描述注解的注解
      • @Target:描述注解能够作用的位置
      /*
      	ElementType取值
      		1、TYPE:可以作用于类上
      		2、METHOD:可以作用于方法上
      		3、FIELD:可以作用于成员变量上
      */
      	@Target(value={ElementType.TYPE}) // 表示该注解只能作用于类上
      	public @interface MyAnno {
      	}
      
      • @Retention:描述注解被保留的阶段
      /*
      	RetentionPolicy取值:
      		1、SOURCE:表示该注解码不会保留到class字节码文件中
      		2、CLASS:表示该注解码会保留到class字节码文件中。不会被JVM读取到
      		3、表示该注解被保留到class字节码文件中,会被JVM读取到
      */
      @Retention(value = RetentionPolicy.RUNTIME) // 表示该注解被保留到class字节码文件中,会被JVM读取到
      public @interface MyAnno {
      }
      
      • @Documented:描述注解是否被抽取到api文档中
      • @Inherited:描述注解是否被子类继承
    解析注解
    • 获取注解中定义的属性值,称注解解析

      1、获取注解定义的位置的对象
      2、获取指定的注解获取指定的注解,getAnnotation(properties.class)
      3、调用注解中的抽象方法来获取配置属性值
      
      // 注解文件
      @Target(value = {ElementType.TYPE})
      @Retention(RetentionPolicy.RUNTIME)
      public @interface properties {
          String  className();
          String methodName();
      }
      
      // 类文件
      public class Demo1 {
          public void show(){
              System.out.println("demo1..show....");
          }
      }
      
      // 测试文件
      @properties(className = "cn.annotation.Demo1",methodName = "show")
      public class ReflectTest {
          public static void main(String[] args) throws Exception{
                 /*
                     需求:写一个"框架",可以帮我们创建任意类的对象,并且执行其中任意方法
                 */
              // 1.解析注解
              // 1.1 获取改类的字节码文件
              Class<ReflectTest> reflectTestClass = ReflectTest.class;
              // 1.2 获取上边的字节码文件对象
              // 在内存中生成了一个该注解接口的子类实现对象
              properties annotation = reflectTestClass.getAnnotation(properties.class);
              // 1.3 调用注解对象中定义的抽象方法,获取返回值
              String className = annotation.className();
              String methodName = annotation.methodName();
              // 3.加载该类进内存,
              Class cls=Class.forName(className);
              // 4.创建对象
              Constructor constructor = cls.getConstructor();
              Object obj = constructor.newInstance();
              // 5.获取方法对象
              Method method = cls.getMethod(methodName);
              // 6.执行方法
              method.invoke(obj);
          }
      }
      
    练习
    • @Target(ElementType.METHOD)
      @Retention(RetentionPolicy.RUNTIME)
      public @interface Check {
      }
      
      public class Calculator {
          @Check
          public void add(){
              System.out.println("1+0="+(1+0));
          }
          @Check
          public void sub(){
              System.out.println("1-0="+(1-0));
          }
          @Check
          public void mul(){
              System.out.println("1*0="+(1*0));
          }
          @Check
          public void div(){
              System.out.println("1/0="+(1/0));
          }
          public void show(){
              System.out.println("永无bug...");
          }
      }
      
      /*
       简单的测试框架
          当主方法执行后,会自动执行被检查的所有方法(加了Check注解的方法),判断方法是否有异常,记录到文件中
      */
      public class TestCheck {
          public static void main(String[] args) throws IOException {
              // 1.创建计算器对象
              Calculator c=new Calculator();
              // 2.获取字节码文件对象
              Class  cls= c.getClass();
              // 3.获取所有的方法
              Method[] methods = cls.getMethods();
              int num=0; //出现异常的次数
              BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("day17\\src\\cn\\calculator\\bug.txt"));
              for (Method method : methods) {
                  // 4.判断方法上是否有Check注解
                  if(method.isAnnotationPresent(Check.class)){
                      try {
                          // 5.执行有Check注解的方法
                          method.invoke(c);
                      } catch (Exception e) {
                          // 6.捕获异常
      
                          // 记记录到bug文件中
                          num++;
                          bufferedWriter.write(method.getName()+"方法出现异常了");
                          bufferedWriter.newLine();
                          bufferedWriter.write("异常的名称:"+e.getCause().getClass().getSimpleName());
                          bufferedWriter.newLine();
                          bufferedWriter.write("异常的原因:"+e.getCause().getMessage());
                          bufferedWriter.newLine();
                          bufferedWriter.write("-------");
                          bufferedWriter.newLine();
                      }
                  }
              }
              bufferedWriter.write("本次测试一共出现"+num+"次异常");
              bufferedWriter.newLine();
              bufferedWriter.flush();
              bufferedWriter.close();
              
          }
      }
      
      /*
      大多数时候我们不会定义注解,只是使用注解
      注解给编译器用,给解析程序用
      注解不是程序的有一部分,可以将注解理解为一个标签
      */
      
    展开全文
  • 它可以声明在包、类、字段、方法、局部变量、方法参数等前面,用来对这些元秦进行说明,注释。 *概念描述︰ *JDK1.5之后新特性 *说明程序 *使用注解︰@注解名称 *作用分类∶ 1.编写文档:通过代码里标识注解...

    注解的概述

    注释:用文字描述程序,给程序员看的。
    注解:说明程序的,给计算机看的。
    *定义:注解(Annotation),也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性。与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面,用来对这些元秦进行说明,注释。
    *概念描述︰
    *JDK1.5之后的新特性
    *说明程序的
    *使用注解︰@注解名称
    *作用分类∶
    1.编写文档:通过代码里标识的注解生成文档【生成文档doc文档]】
    2.代码分析:通过代码里标识的注解对代码进行分析【使用反射】
    3.编译检查∶通过代码里标识的注解让编译器能够实现基本的编译检查(override)

    JDK中预定义的一些注解

    	@Override:检测被该注解标注的方法是否是继承自父类(接口)的
    	@Deprecated:将该注解标注的内容已经过时
    	@SuppressWarnings:压制警告
    	一般传递参数all  @SuppressWarnings("all")
    

    自定义注解
    格式:

    		元注解
    			Public @interface 注解名称{}
    		本质:注解本质上就是一个接口,该接口默认继承Annotation接口
    			public interface com.company.annotation.MyAnno extends java.lang.annotation.Annotation { }
    
    /**
     * 注解javadoc演示
     * @author itcat
     * @version 1.0
     * @since 1.5
     */
    public class AnnoDemo01 {
        /**
         * 计算两数的和
         * @param a 整数
         * @param b 整数
         * @return 两数的和
         */
        public int add(int a,int b){
            return a+b;
        }
        
    }
    
    public class AnnoDemo02 {
        @Override
        public String toString() {
            return super.toString();
        }
    
        @Deprecated
        public void show1(){
            //有缺陷
        }
    
    
        @MyAnno2
        public void show2(){
            //替代show1方法
        }
    
        public void demo(){
            show1();
        }
    }
    
    

    自定义注解-属性定义

    • 自定义注解
    • 格式
    •  元注解
      
    •  Public @interface 注解名称{
      
    •      属性列表;
      
    •  }
      
    • 本质:注解本质上就是一个接口,该接口默认继承Annotation接口
    •  *public interface com.company.annotation.MyAnno extends java.lang.annotation.Annotation { }
      
    • 属性:接口中的抽象方法
    •  要求:
      
    •      1.属性的返回值类型有下列取值
      
    •          基本数据类型
      
    •          String
      
    •          枚举
      
    •          注解
      
    •          以上类型的数组
      
    •       2.定义了属性,在使用时需要给属性赋值
      
    •           1.如果定义属性时,使用default关键字给属性默认初始化值,则使用注解时,可以不进行属性的赋值
      
    •           2.如果只有一个属性需要赋值,并且属性的名称是value,则value可以省略,直接定义值即可
      
    •           3.数组赋值时,值使用{}包裹。如果数组中只有一个值,则{}可以省略
      

    枚举类型:Person

    package com.company.annotation;
    
    public enum Person {
        p1,p2
    }
    

    注解类型:

    public @interface MyAnno2 {
    }
    
    @MyAnno( value = 1,per = Person.p1,anno2 = @MyAnno2,strs = {"abc","bcd"})
    public class Worker {
    }
    
    public @interface MyAnno {
        //public abstract String name() default "张三";
        int value();
        Person per();//枚举类型
        MyAnno2 anno2();//注解类型
        String[] strs();
    
        //int show1();
    
    
    //
    
    }
    

    自定义注解-元注解

    • 元注解:用于描述注解的注解
    • @Target :描述注解能够作用的位置
    •      ElementType取值:
             TYPE:可以作用于类上
             METHOD:可以作用于方法上
             FIELD:可以作用于成员变量上
      
    • @Retention:描述注解被保留的阶段
    •      @Retention(RetentionPolicy.RUNTIME):当前被描述的注解会保留到class字节码文件中,并被JVM读取到
      
    • @Documented:描进注解是否被抽取到api文档中
    • @Inherited :描述注解是否被子类继承
    @Target(value = {ElementType.TYPE})//表示该MyAnno3注解只能作用在类上
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    public @interface MyAnno3 {
    }
    

    注解-解析注解

    public class Demo1 {
        public void show(){
            System.out.println("Demo1...show...");
        }
    }
    
    public class Demo2 {
        public void show(){
            System.out.println("Demo2...show...");
        }
    }
    
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 描述需要执行的类名和方法名
     */
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface pro {
        String className();
        String methodName();
    }
    
    
    package com.company.annotation;
    
    import java.io.InputStream;
    import java.lang.reflect.Method;
    import java.util.Properties;
    
    /**
     * 框架类
     */
    
    @pro(className = "com.company.annotation.Demo1",methodName = "show")
    public class ReflectTest {
        public static void main(String[] args) throws  Exception {
            //可以创建任意类的对象,可以执行任意方法
    
            /*
                前提:不能改变该类的任何代码,可以创建任意类的对象,可以执行任意方法
             */
    
            //1.解析注解
            //1.1 获取该类的字节码文件对象
            Class<ReflectTest> reflectTestClass=ReflectTest.class;
            //2.获取上边的注解对象
    
            /*
                public class proImpl implements pro{
                    public String className( ){
                        return "cn.itcast.annotation . Demo1" ;
                        }
                    public String methodName(){
                        return "show" ;
                        }
                    }
    
             */
            pro an=reflectTestClass.getAnnotation(pro.class);//其实就是在内存中生成了一个该注解接口的子类实现对象
            //3.调用注解中定义的抽象方法,获取返回值
            String className=an.className();
            String methodName=an.methodName();
            System.out.println(className);
            System.out.println(methodName);
    
            //4.加载该类进内存
            Class cls=Class.forName(className);
            //5.创建对象
            Object obj=cls.newInstance();
            //6.获取方法对象
            Method method=cls.getMethod(methodName);
            //7.执行方法
            method.invoke(obj);
    
    
    
        }
    }
    
    

    简单的测试框架

    定义注解

    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface Check {
    }
    

    定义计算的类,进行加减乘除

    
    public class Calculator {
        //加法
        @Check
        public void add() {
            System.out.println("1 + 0 =" + (1 + 0));
        }
    
        //减法
        @Check
        public void sub() {
            System.out.println("1 - 0 =" + (1 - 0));
        }
    
        //乘法
        @Check
        public void mul() {
            System.out.println("1 * 0 =" + (1 * 0));
        }
    
        //除法
        @Check
        public void div() {
            System.out.println("1 / 0 =" + (1 / 0));
        }
    
        public void show(){
            System.out.println("永无bug......");
        }
    
    }
    
    • 简单的测试框架

       当主方法执行后,会自动检测所有的方法(加了check注解的方法),判断方法是否有异常,记录到文件当中
      

    */

    package com.company.annotation.demo;
    
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    
    public class TestCheck {
        public static void main(String[] args) throws IOException {
            //1.创建计算器对象
            Calculator c=new Calculator();
            //2.获取字节码文件对象   一般创建对象用来直接调用该对象需要的方法,但是这里是获得所有的方法,所以可以通过获取字节码文件对象来获得
            Class<? extends Calculator> cls=c.getClass();
    
            //3.获取所有的方法
            Method[] methods=cls.getMethods();
            int number=0;//出现异常的次数
            BufferedWriter bw=new BufferedWriter(new FileWriter("bug.txt"));
            for (Method method : methods) {
                //4.判断方法上是否有Check注解
                if (method.isAnnotationPresent(Check.class)){
                    //5.有,执行
                    try {
                        method.invoke(c);
                    } catch ( Exception e) {
                        //6.捕获异常
    
                        //记录到文件中
                        number++;
                        bw.write((method.getName()+"方法出异常了"));
                        bw.newLine();
                        bw.write("异常的名称:"+e.getCause().getClass().getSimpleName());
                        bw.newLine();
                        bw.write("异常的原因:"+e.getCause().getMessage());
                        bw.newLine();
                        bw.write("----------------------------------");
                        bw.newLine();
                        //e.printStackTrace();
                    }
                }
            }
            bw.write("本次测试一共出现"+number+"次异常");
            bw.flush();
            bw.close();
    }
    }
    
    

    运行之后,bug.txt记录的内容:

    div方法出异常了
    异常的名称:ArithmeticException
    异常的原因:/ by zero
    ----------------------------------
    本次测试一共出现1次异常
    
    展开全文
  • 三关传入参数id=1页面正常显示,然后测试闭合方式。...在这里做一个简单记录,判断字段数时候,使用order by 15还是能查询成功,具体问题出现在哪我也不清楚,所以用了另一可以判断字段数的方法:就是unio

    二十三关传入参数id=1页面正常显示,然后测试闭合方式。当输入单引号时,页面报错,说明很可能是单引号闭合
    在这里插入图片描述加上注释符号时还是同样报错!!
    尝试了–+注释 和#注释还是一样报错

    在这里插入图片描述尝试一下加上)括号和))
    在这里插入图片描述在这里插入图片描述还是报错,此时很可能就是注释符号被过滤掉了,没有起到作用
    在这里插入图片描述使用单引号闭合已经成功了!!
    可以使用联合查询,报错注入等方式可以来获取数据库信息
    在这里插入图片描述
    在这里做一个简单的记录,判断字段数的时候,使用order by 15还是能查询成功,具体问题出现在哪我也不清楚,所以用了另一种可以判断字段数的方法:就是union select 1,2,3
    在这里插入图片描述显然报错了。所以有三个字段。
    在这里插入图片描述查询到了数据库名了。以下操作都省略了

    展开全文
  • 2.4.4 变量的作用域和生存周期 44 2.4.5 常量的定义 45 2.5 数据类型转换 45 2.5.1 隐式类型转换 45 2.5.2 显式类型转换 46 2.6 运算符及表达式 47 2.6.1 算术运算符 47 2.6.2 赋值运算符 48...
  • caono佳能清零方法

    2011-06-30 16:58:04
    对于有进纸键、清洗键打印机,用按键清零(复位)的方法是:同时按住进纸键、清洗键开机,待电源灯闪两次松开进纸键和清洗键,待电源灯再闪两次后,按住清洗键秒,这时所有指示灯同时闪一下,清零(复位)结束;...
  • AOP为Aspect Oriented Programming缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能统一维护技术。在日常开发当中经常用来记录日志,方法跟踪、事务,权限等 切面方法说明: @...
  • 局部变量指是在方法里定义变量。 成员变量被分为类Field和实例Field两,见上图。其中类Field从类准备阶段起开始存在,直到系统完全销毁这个类,类Field作用域与这个类生存范围相同;而实例Field则从该类...
  • 2.4.4 变量的作用域和生存周期 44 2.4.5 常量的定义 45 2.5 数据类型转换 45 2.5.1 隐式类型转换 45 2.5.2 显式类型转换 46 2.6 运算符及表达式 47 2.6.1 算术运算符 47 2.6.2 赋值运算符 48...
  • 下面简要说明各部分电路的作用与要求: 1、键盘输入电路: 主要把实验过程中的一些功能通过键盘设置到系统中。 2、显示电路: 显示主叫与被叫电路的电话号码,同时显示通话时间。 3、输入输出扩展电路: 显示电路...
  • 因素,说明了减少功耗、增加存取速度的译码电路的设计方法,分析介绍了logica effort理论在译码电路设计中的应用。并为非对称逻辑门建立了电路模型,分析 了其优势,指出了其在译码电路中的作用
  • 网上这种方法的代码也很多,这里就不上了。 下面将阐述我的方法以及给出例子代码。  我有两思路,一是高级绘图层面的(不涉及到底层操作),一是底层的。我只给出了第一的代码,因为我不会底层操作。...
  • 利用多种搜索方法获取有用信息和商机,由单一向集群化、智能化发展,以及向定向邮件搜索技术延伸,寻找网上营销目标将成为一件易事。 2、信息发布功能 网络信息扩散范围、停留时间、表现形式、延伸效果、...
  • 引 言 <br/> Internet的发展过程中有许多标志—从令人振奋的“信息高速公路”到令人...最后,本章还描述了信令及统计计费机制所起到的关键性的作用。 <br/> ?第3章“每一跳分组处理”详细地描述了如何控制每个...
  • excel使用

    2012-11-25 17:06:01
    合并不同单元格的内容,还有一种方法是利用CONCATENATE函数,此函数的作用是将若干文字串合并到一个字串中,具体操作为“=CONCATENATE(B1,C1)”。比如,假设在某一河流生态调查工作表中,B2包含“物种”、B3包含...
  • 加入的这个函数的作用就是移除字符串开头和结尾的空白字符。 12.最后,如果输入错误了,重新回到登录对话框时,我们希望可以使用户名和 密码框清空并且光标自动跳转到用户名输入框,最终的登录按钮的单击事件的槽 ...
  • 晶振的作用:它结合单片机内部的电路,产生单片机所必须的时钟频率,单 片机的一切指令的执行都是建立在这个基础上的,晶振的提供的时钟频率越 高,那单片机的运行速度也就越快。MCS-51 一般晶振的选择范围为1~ 24...
  • 算放大器(0pe船t50nalAmNIfZG r)简称0p放大 器,原被用作模拟计算机中...第七章,收集了十种实用电路,这些电路是第—‘挛到第五章所未曾直接提及。 本书旨在通俗易橙,简明扼要,故可能有疏漏之处,望 族者指正。
  • DC-DC开关转换器的作用是将一个直流电压有效转换成另一个。高效率DC-DC转换器采用三项基本技术:降压、升压,以及降压/升压。 降压转换器用于产生低直流输出电压,升压转换器用于产生高直流输出电压,降压/升压转换器则...
  • 这些问题都是以下事实症状:Slack和类似工具使用通道模型是构造异步通信非常糟糕的方法。 但是,异步通信是当今工作方式基础: 经理,PM和全天开会其他人需要在会议之间几分钟内或一天结束时分批...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 254
精华内容 101
关键字:

十种说明方法的作用