lengjingbuliaoyidian
文章8
标签6
分类5
javascript

javascript

JavaScript是什么(如有不懂得可以查看mdn)

  1. 含义:简称js,是一种运行在客户端(浏览器)的编程语言(脚本语言),实现人机交互效果。
  2. 组成:
  • ECMAScript: 规定了js基础语法核心知识(如:变量,分支语句ect)
  • Web APIS:DOM(操作文档,比如 对页面元素进行移动,大小,添加删除等操作)、BOM(操作浏览器,比如页面弹窗,检查窗口宽度、存储数据到浏览器等等)
  1. 脚本语言的定义:无需编译,可以有某种解释器直接执行(sql、python、html、css、JavaScript)直接有某种解释器(引擎)解释执行,逐行从上往下解释执行。

作用:

  1. 网页特效(监听用户的一些行为让网页做出对应的反馈)
  2. 表单验证(针对表单数据的合法性进行判断)
  3. 数据交互(获取后台的数据,渲染到前端)
  4. 服务端编程(node.js)

具有的特点:

  1. 解释型脚本语言:
    JavaScript是一种解释型脚本语言,与C、C++等语言需要先编译在运行不同,使用JavaScript编写的代码不需要运行,可以直接运行。
  2. 弱类型:
    JavaScript是一种弱类型的编程语言,对使用的数据类型没有严格的要求。
  3. 面向对象:
    JavaScript是一种面向对象语言,使用JavaScript不仅可以创建对象,也能操作使用已有的对象。
  4. 动态性:
    JavaScript是一种采用事件驱动的脚本语言,它不需要借助Web服务器就可以对用户的输做出响应。例如我们再访问一个网页时,通过鼠标再网页中进行点击或滚动窗口时,通过JavaScript可以直接对这些事件做出响应。
  5. 跨平台性:
    JavaScript不依赖操作系统,再浏览器中就可以运行。因此一个JavaScript脚本再编写完成后可以再任意系统上运行,只需要系统上的浏览器支持JavaScript即可。

执行顺序:

  • JavaScript代码执行顺序:
    可以写在HTML文档<head>标签与<body>标签中,写在不同的标签中的执行顺序不同

书写位置(3种):

  • 内部(写在body里面):

          <body>
              <!--内部js-->
              <script>
                  <!-- alert:页面弹出警示框-->
                  alert("你好,js")
              </script>
          </body>
    

1.注意事项:
我们将<script>尽量放在HTML文件的底部附近的原因是浏览器会按照代码在文件中的顺序加载HTML,如果先加载的JavaScript期望修改其下方的HTML,那么它可能由于HTML尚未被加载而失败。

  • 外部(通过src引入外部js文件):

      <body>
          <!-- 通过src引入外部js文件-->
          <script src="./myjs/my.js"></script>
      </body>
    
  1. 注意事项:
    <script>标签中间无需写代码,否则会被忽略!外部的JavaScript会使代码更加有序,更易于复用,且没有脚本的混合,HTML也会更加易于读。
  • 内联(代码写在标签内部):

      <body>
          <button onclick="alert('逗你玩玩')">点击我有好运喔</button>
      </body>
    

输入、输出语法:

  • 理解:人和计算机的交互,用户用过键盘、鼠标等向计算机输入信息,计算机处理后再展示结果给用户,这便是一次输入和输出的过程。
  1. 输出语法:

     <body>
         <script>
             // 1.文档输出内容(在后面Ctrl+/ 生成单行注释):向body内输出内容     1. 注意事项:如果输出的内容写的是标签,也会被解析成网页元素
    
             document.write('我是图图小淘气')
             document.write('<h1>面对世界很好奇</h1>')
    
             // 2.alert直接输出 :页面弹出警告对话框
    
             alter('图图真棒')
    
             /*3.控制台打印输出 给程序员调试使用 (开始shift+alt+a生成多行注解)*/
    
             console.log('看一看对与不对')
             console.log('客户端又看不到的地方')   
    
         </script>
     </body>
    

总之,JavaScript 可以通过不同的方式来输出数据:

  • 使用 window.alert() 弹出警告框。

  • 使用 document.write() 方法将内容写到 HTML 文档中。

  • 使用 innerHTML 写入到 HTML 元素。

如需从 JavaScript 访问某个 HTML 元素,您可以使用 document.getElementById(id) 方法。请使用 “id” 属性来标识 HTML 元素,并 innerHTML 来获取或插入元素内容:

        <!DOCTYPE html>
        <html>
        <body>

        <h1>我的第一个 Web 页面</h1>

        <p id="demo">我的第一个段落</p>

        <script>
        document.getElementById("demo").innerHTML = "段落已修改。";
        </script>

        </body>
        </html>
  • 使用 console.log() 写入到浏览器的控制台。
  1. 输入语句:
    显示一个对话框,对话框中包含一条文字信息,用来提示用户输入信息

                     prompt('请输入你的姓名:')
    

变量:

  • 含义:变量是计算机存储数据容器,注意:变量不是数据本身,它仅仅是一个用于存储数据的容器,可以理解为一个个用来装东西的子箱子。

  • 声明(var 、let、const):

              let age=18    //注意let 不允许多次声明一个变量,但是var可以多次声明同一个变量(不太好)
    
  • 精辟: var既可以重新声明,也可以重新赋值;let不能重新声明,可以重新赋值;const 既不能重新声明,也不能重新赋值(专一的好家伙,定义常量时必须赋值)。

  • 变量赋值之后如何更新新值:
    直接给它一个不同的值更新它的值,例如:

              lat age = 18
               age = 19 
    
  • 本质:是程序再内存中申请的一块用来存放数据的小空间

  • 变量命名规则与规范:

  1. 规则:
    • 不能用关键字(有特殊含义的字符,如js中的let、var、const、if、for等)
    • 只能用下划线、字母、数字、$组成,且数字不能开头
    • 字母严格区分大小写
  2. 规范:
    • 起名要由意义
    • 遵守小驼峰命名法(第一个单词的首字母小写,后面每一个单词的首字母大写。如:userName)

优先级(同时使用多个运算符编写程序时,会按照某种顺序先后执行):

JavaScript中优先级越高越先被执行,优先级相同时从左向右执行。

  • (乘、除、取余优先级相同)>(加、减优先级相同)
  • 使用()可以提升优先级
  • 总之:先乘除后加减,有括号的先算括号里面的

数据类型

  • 数字类型(number):其中包括整型数和浮点数
    1.注意事项:
    NaN代表一个计算错误。它是一个不正确的或者是一个未被定义的数字操作所得到的结果(NaN是粘性的:任何对NaN的操作都会返回Nan)。

  • 字符串类型(String):
    通过单引号(’’)、双引号(””)、或则反引号(``)包裹的数据都叫字符串,单双引号没有本质上的区别。
    2.注意事项:

  • 无论是单双引号都必须成对使用

  • 单引号/双引号可以互相嵌套,但是不可以自己嵌套自己。

  • 必要时可以使用转义字符\,输出单引号或双引号

          console.log('我是图图"小淘气"')
          console.log("我是图图'小淘气'")
          console.log('我是图图\'小淘气\'')
    

字符串的拼接:

        let age = 18
        //方法一:模板字符串(外面用反引号``,里面用${变量名})
        document.write(`我今年${age}岁了`)  
        //方法二;直接用+号拼接法
        document.write('我今年' + age + '岁了')
  • 布尔类型(Boolean):
    有两个固定的值,表示为真时(true),表示为假时(false)

  • 未定义类型(undefined):
    未定义是比较特殊的类型,只有一个值undefined。(用在只声明变量,不赋值的情况下,变量的默认值为undefined

  • 空类型(null):
    JavaScript中的null仅仅是一代表”无”,”空”,”值未知”的特殊值
    3.注意事项:

              null和undefined区别:
              undefined表示`没有赋值`(还有就是如果检测到变量是undefined就说明没有值传过来)
              null表示`赋值了,但是内容为空`(官方解释:把null作为尚未创建的对象,说白了就是,有一个变量里面存放的是一个对象呢,但是对象还没有创建好,可以先给个null,后面再来赋值)
    
              console.log(undefined + 1)  //结果为NaN
              console.log(null + 1)  //结果为1,null是赋了值,但是值为空
    

强制类型转换

  • 强制类型转换是指将一个数据类型强制转换为其他的数据类型。一般是指,将其它的数据类型转换成为String、Number、Boolean。

  • 转换为String类型:
    有三种方式:toString()、String()、拼串。

  1. toString():
    调用被转换数据类型的toString()方法,该方法不会影响到原变量,它会将转换的结果返回,但是要注意的是:null和undefined这两个值没有toString()方法,如果调用他们的方法会报错。

    let a =1234
    a=a.toString()
    console.log(a)
    console.log(typeof a)

  2. String():
    调用该函数,并将被转换的数据作为参数传递给函数,使用String()函数作强制转换时,对于Number和Boolean实际上就是调用toString()方法,但是对于null和undefined,就不会调用toString()方法,而是会将null和undefined直接转换为:”null”、”undefined”。

    let a =1234
    a=String(a)
    console.log(a)
    console.log(typeof a)

  3. 为任何数据类型+""

                     let a=1234
                     a=a+""
                     console.log(a)
                     console.log(typeof a)
    
  • 转换为Number类型:
    有三个函数可以把非数值转换为数值:Number()、parseInt()、parseFloat()。Number()可以用用来转换任意类型的数据,而后两只能用于转换字符串。
  1. Number()函数:

    • 字符串 –> 数字

                1.如果是纯数字的字符串,则直接转换为数字
                2.如果字符串中有非数字的内容,则转换为NaN
                3.如果是字符串是一个空串或者是一个全是空格的字符串,则转换为0
      
    • Boolean –>数字

                1.true-->1
                2.false-->0
      
    • null –>数字

                null -->0
      
    • undefined –>数字

                undefined  -->NaN
      
  2. parseInt():
    把一个字符串转换为一个整数

  3. parseFloat():
    把一个字符串转换为一个浮点数

注意:

            如果是对非String类型使用parseInt()或者parseFloat(),它会先将其转换为String然后再操作。
  • 转换为Boolean类型:
    只使用Boolean()函数
  1. Boolean()函数:

    • 数字–>Boolean

除了0和NaN,其余都是true
- 字符串–>Boolean
除了空串,其余都是true
- null 和 undefined都会转换为false
- 对象也会转换为true

控制台输出语句和检测数据类型

  • 用过typeof关键字检测数据类型
    typeof运算符可以返回被检测的数据类型。它支持两种语法形式
  1. 作为运算符: typeof x (常用的写法)
  2. 函数形式: typeof(x)
    总之:最后得到的结果都是一样的

类型转换

  • 隐式转换:某些运算符被执行时,系统内部自动将数据类型进行转换。
  • 规则:
    1. +号两边只要有一个是字符串,都会把另外一个转成字符串
    2. 除了+号外的算术运算符,比如 - * /等都会把数据转成数字类型
  • 小技巧:
    由于转换类型不明确,会有点小坑:
    1. +号作为正号解析可以转成数字型

    2. 任何数据和字符串 相加结果都是字符串

         console.log('one'+1)  //one1
         console.log(2-'2')    //0
         console.log(+12)     //12
         console(+'123')      //123  转换成数字型
      

赋值运算符:(对变量进行赋值的运算符)

  • 一元运算符:(自增,自减)

     <!-- 前置自增和后置自增的在运算时区别,but再单独使用的时候没有差别 -->
     let i =1
     console.log(++i + 2) //结果是4
     //注意i=2, i先自加1,变为2之后,在和后面的2相加
    
     console.log(i++ + 2)  //结果是3
     注意此时i=1 ,先和2相加,先运算输出完毕后,i再自加是2
    
  • 比较运算符:(比较结果为Boolean型,即只会得到true 或 false)
    其他的都一样,只有以下特殊的:

      ==:左右两边值是否相等
      ===:左右两边值是否类型和值都相等
      !==:左右两边是否不全等
      //对比:
      =:是赋值
      ==:是判断
      ===:是全等(开发中判断是否相等,强烈推荐使用===)
    

注意:

            <!-- 不同类型之间比较会发生隐式转换,最终把数据隐式转换成number类型再比较 例如: 2=='2'结果为true  -->
            <!-- 字符串比较的字符对应的ASCII码:从左往右一次比较,如果第一位一样在比较第二位,以此类推 -->
            <!-- NaN不等于任何值,包括它本身(只要涉及到全为false) -->
            <!-- 尽量不要比较小数,因为小数有精度问题 -->
  • 逻辑运算符:

          &&(一假为假)     ||(一真为真)     !(取反)
    

运算符优先级

  1. 小括号
  2. 一元运算符(++ – !(优先级高))
  3. 算数运算符(先 * / % 后 + -)
  4. 关系运算符(> >= < <=)
  5. 相等运算符(== != === !==)
  6. 逻辑运算符(先&& 后 ||)
  7. 赋值运算符(=)
  8. 逗号运算符(,)

条件语句

  • 含义:通过判断指定表达式的值来决定执行还是跳过某些语句,最基本的语句有:
  1. if…else
  2. switch …case(需要注意的是一旦符合case的条件程序会一直运行到结束,所以我们一般会在case中添加break作为语句的结束,判断值一定是要
    ===的)

循环语句

  • 含义:只要满足一定的条件将会一直执行,最基本的语句有:
  1. while
  2. do …while
  3. for

跳转控制

  • break:结束最近的一次循环,可以在循环和switch语句中使用
  • continue:结束本次循环,执行下一次循环,只能在循环中使用

函数

  • 作用:声明一个需要的函数,可以把具有相同或相似的逻辑代码“包裹起来”,通过函数调用执行,做到精简代码方便复用。function()->是被设计为执行特定任务的代码块

  • 声明:

              function 函数名(){
                  方法体
              }
              <!-- 调用 -->
              函数名()
              <!-- 函数的复用代码和循环重复代码用什么不同:
              - 循环代码写完立即执行,不能很方便控制执行位置
              - 函数随时调用,随时执行,可重复调用
               -->
    
  • 有返回值的函数

  1. 在函数体中使用return关键字能将内部的执行结果交给函数外部使用

         function getTotalPrice(x,y){
             return x+y
         }
         let sum=getTotalPrice(1,2)
         console.log(sum)  //结果为3
    
  2. return 后面代码不会在被执行,会立即结束当前函数,所以return后面的数据不要换行写

  3. return 函数可以没有return,这种情况函数默认返回值为undefined,例如:

         function fn(){
    
         }
         let re = fn()
         console.log(re)   //返回结果为undefined
    

使用误区

  1. JavaScript中允许在字符串中使用断行语句:

                 var x =
                 "Hello World!";
    

但是,在字符串中直接使用回车换行是会报错的;所以字符串断行需要使用反斜杠(),如下所示:

                var x = "Hello \
                World!";
  1. Undefined 不是 Null
    在 JavaScript 中, null 用于对象, undefined 用于变量,属性和方法。对象只有被定义才有可能为 null,否则为 undefined。

             if (typeof myObj !== "undefined" && myObj !== null) 
    
  2. 程序块作用域
    在每个代码块中 JavaScript 不会创建一个新的作用域,一般各个代码块的作用域都是全局的。以下代码的的变量 i 返回 10,而不是 undefined:

             实例
             for (var i = 0; i < 10; i++) {
                 // some code
             }
             return i;
    

thi关键字:

在JavaScript中this不是固定不变的,它会随着执行环境的改变而改变

  • 在方法中,this表示该方法所属的对象

              var person = {
              firstName: "John",
              lastName : "Doe",
              id       : 5566,
              fullName : function() {
                  return this.firstName + " " + this.lastName;
              }
              };
    
  • 如果单独使用,this表示全局对象

              //在浏览器中,window就是该全局对象为`object Window`
              var x = this
              //严格模式下,如果单独使用,this 也是指向全局(Global)对象。
              "use strict";
              var x = this;
    
  • 在函数中,this表示全局对象

              //在函数中,函数的所属者默认绑定到this上
              function myFunction(){
                  return this;
              }
    
  • 在函数中,严格模式下,this是undefined

              //严格模式下函数是没有绑定到 this 上,这时候 this 是 undefined。
              "use strict";
              function myFunction() {
              return this;
              }
    
  • 在事件中,this表示接受事件的元素

              在 HTML 事件句柄中,this 指向了接收事件的 HTML 元素:
              <button onclick = "this.style.display='none'">点我后我就消失不见了</button>
    
  • 类似call() 和 apply() 方法可以将this引用到任何对象,即显示函数绑定
    在JavaScript中函数也是对象,对象则有方法,call()、apply()就是函数对象方法。这两个方法异常强大,允许切换函数执行的上下文环境,即切换this绑定的对象。例如:

             <p id="demo"></p>
              <script>
              var person1 = {
              fullName: function() {
                  return this.firstName + " " + this.lastName;
              }
              }
              var person2 = {
              firstName:"John",
              lastName: "Doe",
              }
              var x = person1.fullName.call(person2); //// 返回 "John Doe"
              document.getElementById("demo").innerHTML = x; 
              </script>
    

表单及其验证、验证API

  • 表单验证:HTML表单验证可以通过JavaScript来完成
    HTML 表单验证可以通过 JavaScript 来完成。
    以下实例代码用于判断表单字段(fname)值是否存在, 如果不存在,就弹出信息,阻止表单提交:

          <!DOCTYPE html>
              <html>
              <head>
              <meta charset="utf-8">
              <script>
              function validateForm() {
                  var x = document.forms["myForm"]["fname"].value;
                  if (x == null || x == "") {
                      alert("需要输入名字。");
                      return false;
                  }
              }
              </script>
              </head>
              <body>
    
              <form name="myForm" action="demo_form.php"
              onsubmit="return validateForm()" method="post">
              名字: <input type="text" name="fname">
              <input type="submit" value="提交">
              </form>
    
              </body>
              </html>
    
  • HTML表单自动验证:
    HTML表单验证也可以通过浏览器来自动完成,就是设置必填required,判断其值是否为空,为空时候required属性会阻止表单的提交:

              <form action="demo_from.php" method="post">
              <input type="text" name="fname" required="required">
              <input type="submit" value="提交">
              </form>
    
              1.E-mail 验证:在数据在送往服务器前对数据通过条件自动检测
              下面的函数检查输入的数据是否符合电子邮件地址的基本语法。
    
              意思就是说,输入的数据必须包含 @ 符号和点号(.)。同时,@ 不可以是邮件地址的首字符,并且 @ 之后需有至少一个点号:
    
              function validateForm(){
              var x=document.forms["myForm"]["email"].value;
              var atpos=x.indexOf("@");
              var dotpos=x.lastIndexOf(".");
              if (atpos<1 || dotpos<atpos+2 || dotpos+2>=x.length){
                  alert("不是一个有效的 e-mail 地址");
                  return false;
              }
              }
              下面是连同 HTML 表单的完整代码:
    
              实例
              <form name="myForm" action="demo-form.php" onsubmit="return validateForm();" method="post">
                  Email: <input type="text" name="email">
                  <input type="submit" value="提交">
              </form>
    
  • 数据验证
    数据验证用于确保用户输入的数据是有效的。典型的数据验证有:

  1. 必需字段是否有输入?
  2. 用户是否输入了合法的数据?
  3. 在数字字段是否输入了文本?
    大多数情况下,数据验证用于确保用户正确输入数据。
    数据验证可以使用不同方法来定义,并通过多种方式来调用。例如:

服务端数据验证是在数据提交到服务器上后再验证。
客户端数据验证是在数据发送到服务器前,在浏览器上完成验证。

  • HTML 约束验证
    HTML5 新增了 HTML 表单的验证方式:约束验证(constraint validation)。
    约束验证是表单被提交时浏览器用来实现验证的一种算法。
    HTML 约束验证基于:
  1. HTML 输入属性
  2. CSS 伪类选择器
  3. DOM 属性和方法

验证API:

  • 约束验证 DOM 方法
  1. checkValidity():如果 input 元素中的数据是合法的返回 true,否则返回 false。
  2. setCustomValidity()
    设置 input 元素的 validationMessage 属性,用于自定义错误提示信息的方法。

使用 setCustomValidity 设置了自定义提示后,validity.customError 就会变成 true,checkValidity 总是会返回 false。如果要重新判断需要取消自定义提示,方式如下:

setCustomValidity(‘’)
setCustomValidity(null)
setCustomValidity(undefined)

            <!DOCTYPE html>
            <html lang="en">
            <head>
                <meta charset="UTF-8">
                <meta name="viewport" content="width=device-width, initial-scale=1.0">
                <title>Document</title>
                <script>
                    function myFunction(){
                        var x =document.getElementById("id1");
                        x.setCustomValidity("");  //使用前先取消定义,否则下次点击checkValidity总会返回false,若是不取消下次直接默认checkValidity==false 
                        if(x.checkValidity() == false){
                            x.setCustomValidity("错误");
                            document.getElementById("demo").innerHTML=x.validationMessage;
                        }else{
                            x.setCustomValidity("对啦");
                            document.getElementById("demo").innerHTML=x.validationMessage;
                        }
                    }
                </script>
            </head>

            <body>
                <p>输入数字并点击验证按钮:</p>
                <input type="number" id="id1" max="300" min="100" required>
                <button type="submit" onclick="myFunction()">点我</button>
                <p>如果输入数字100-300以外,会提示错误信息。</p>
                <p id="demo"></p>
                
            </body>
            </html>

void()

  • 该操作指定要计算一个表达式但是不返回值(但是括号内的表达式还是要运行的)。

  • javascript:void(0):相当于一个死链接,什么都不会发生。

              <a href="javascript:void(0)">单击此处什么也不会发生</a>
    
  • 区别href=”#”与href=”javascript:void(0)”

#包含了一个位置信息,默认的锚是#top 也就是网页的上端。

而javascript:void(0), 仅仅表示一个死链接。

在页面很长的时候会使用 # 来定位页面的具体位置,格式为:# + id。

如果你要定义一个死链接请使用 javascript:void(0) 。

            <a href="javascript:void(0);">点我没有反应的!</a>
            <a href="#pos">点我定位到指定位置!</a>
            <br>
            ...
            <br>
            <p id="pos">尾部定位点</p>

    
注解和反射

注解和反射

注解的含义:

  • Annotation的作用:不是程序本身,可以对程序做出解释;可以被其他程序(比如:编译器等)读取,注解可以用来修饰类、方法、变量、参数等,可以用来检查代码质量、约束开发者的编程风格、提高代码的可读性和可维护性(检查、约束)。
  • 格式:以“@注释名”在代码中存在,还可以在后面添加一些参数值
  • 使用范围:可以附加在package、class、method、filed等上面,相当于给他们添加了额外的辅助信息,可以通过反射机制编程实现对这些元数据的访问

内置注解:

  • @Override: 定义在java.lang.Override中,此注解只适用于修饰方法,表示一个方法声明打算重写超类中的另外一个方法声明。

  • @Deprecated:定义在Java.lang.Deprecated中,此注解可以用于修饰方法,属性,类,表示不鼓励程序员使用这样的元素(通常事因为它很危险或者存在更好的选择),但是可以此方法可以运行。

  • @SuppressWarnings:定义在Java.lang.SuppressWarnings中,用来抑制编译时的警告信息(后面要有参数才能正确使用),例如:

      @SuppressWarnings("all");
      @SuppressWarnings("unchecked");
      @SuppressWarnings("unchecked","deprecation");
    

元注解:

  • 作用:负责注解其他注解,Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明。

  • 类型:@Target ,@Retention, @Documented ,@Inherited (这些类型和他们所支持的类在Java。狼。annotation包中可以找到。)

          @Target:用于描述注解的使用范围(即被描述的代码可以用在那些地方)
    
          @Retention:表示需要在说明级别保存该注解信息,用于描述注解的生命周期(Runtime>class>source)
          @Document:说明该注解将被包含在Javadoc 中
          @Inherited:说明子类可以继承父类中的该注解
    
  • 格式:
    @Target(value ={ElementType.METHOD,ElementType.TYPE})
    @Retention(value=RetentionPolicy.RUNTIME)

自定义注解:

  • 用法:使用@interface自定义注解时,自动继承java.lang.annotation.Annotation接口
  • 归纳:
  1. @interface用来声明一个注解,格式:public @interface 注解名{定义内容}
  2. 其中的每一个方法实际上是声明一个配置参数
  3. 方法的名称就是参数的名称
  4. 返回值类型就是参数的类型(返回值只能是基本类型,Class,String,enum)
  5. 可以通过default来声明参数的默认值
  6. 如果只有一个参数成员,一般参数名为value
  7. 注解元素必须要由值,定义注解元素时,经常使用空字符串0作为默认值
  • 代码如下:
    package com.st.test;

    //测试自定义注解

    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;

    public class Test03 {
    //注解可以显示赋值,如果没有默认值(default 数值),我们就必须给注解赋值
    @MyAnnotation2(name=”李明” ,schools ={“湖南大学”,”清华大学”} )
    public void test(){}

    //如果自定义的注解只有一个值的时候可以使用value表示,在方法注解表示的时候可以直接省略value
    @MyAnnotation3(“李明”)
    public void test2(){}
    }

    @Target(value={ElementType.METHOD,ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation2{
    //注解的参数:参数类型+参数名();
    String name() ; //赋值为李明
    int age() default 0;
    int id() default -1; //如果默认值为-1,则代表不存在

    String[] schools();
    }
    @Target(value={ElementType.METHOD,ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation3{
    String value();
    }

java反射

  • 特点:Java不是动态语言,但Java可以称之为“准动态语言”。即Java有一定的动态性,我们可以利用反射机制获得此类似动态语言的特性。Java的动态性让在编程的时候更加灵活!

  • 反射:被视为是动态语言的关键,反射机制允许程序在执行期间借助于’Reflection API’获取任何类的内部信息,并直接操作任意对象的内部属性及方法

           Class c=Class.forName("java.lang.String")
    

    加载完类之后,在堆内存的方法中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,通过镜子看到类的结构,所以形象的称为:反射

  • 对比:

  1. 正常的方式:先引用需要的“包类”名称——> 通过new实例化——> 取得实例化对象
  2. 反射方式: 实例化对象——> getClass()方法——> 得到完整的“包类”名称。
  • 反射机制在运行时提供的功能:
  1. 判断任意一个对象所属的类
  2. 可构造任意一个类的对象
  3. 可判断任意一个类所具有的成员变量和方法
  4. 可获取泛型信息
  5. 可调用任意一个对象的成员变量和方法
  6. 可处理注解
  7. 生成动态代理(AOP)
  • 创建对象的五种方式: new、newInstance、clone、反序列化、反射。

  • 代码:

        package com.st.reflection;
        public class Test002 {
        public static void main(String[] args) throws ClassNotFoundException {
      //通过反射获取类的Class对象
     Class c1=Class.forName("com.st.reflection.User");
      System.out.println(c1);
    
     //查看他们是不是属于同一个类,就可以查看他们的哈希一不一样
      Class c2=Class.forName("com.st.reflection.User");
      Class c3=Class.forName("com.st.reflection.User");
      Class c4=Class.forName("com.st.reflection.User");
     //结果是一样的
      //一个类在内存中只有一个Class对象,一个类被加载之后,类的整个结构都会被封装在Class对象中
      System.out.println(c2.hashCode());
      System.out.println(c3.hashCode());
      System.out.println(c4.hashCode());
       }
    }
      
      //实体类:pojo entity
      class User{
       private String name;
       private int id;
       private  int age;
    
      public User(){
    
       }
      public User(String name, int id, int age) {
      this.name = name;
      this.id = id;
      this.age = age;
      }
    
      public String getName() {
          return name;
      }
    
      public int getId() {
          return id;
      }
    
      public int getAge() {
          return age;
      }
    
      public void setName(String name) {
          this.name = name;
      }
    
      public void setId(int id) {
          this.id = id;
      }
    
      public void setAge(int age) {
          this.age = age;
      }
    
      @Override
      public String toString() {
          return "User{" +
                  "name='" + name + '\'' +
                  ", id=" + id +
                  ", age=" + age +
                  '}';
      }
    }
    

获取Class类的实例

  • 若已知具体的类,通过类的class属性获取,该方法最为安全可靠,程序性能最高

              Class clazz =Person.class;
    
  • 已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException

              Class clazz=Class.forName("demo01.Student");
    
  • 已知某个类的实例,调用实例的getClass()方法获取Class对象

              Classclazz=person.getClass();
    
  • 内置基本数据类型可以用类名.TYPE

  • 还可以利用ClassLoader

  • 综合示例:

              package com.st.reflection;
              //测试Class 类的创建方式有哪些
              public class Test003 {
                  public static void main(String[] args) throws ClassNotFoundException {
                      Person person=new Student();
                      System.out.println("这个人是:"+person.name);
    
                      //方式一:通过对象获得
                      Class c1=person.getClass();
                      System.out.println(c1.hashCode());
    
                      //方式二:通过forname获得
                      Class c2 = Class.forName("com.st.reflection.Student");
                      System.out.println(c2.hashCode());
    
                      //方式三:通过类名。class 获得
                      Class<Student> c3 = Student.class;
                      System.out.println(c3.hashCode());
    
                      //方式四:基本内置类型的包装类都有一个Type属性
                      Class c4=Integer.TYPE;
                      System.out.println(c4.hashCode());
    
                      //获取父类类型
                      Class c5=c1.getSuperclass();
                      System.out.println(c5);
    
    
                  }
              }
    
              class Person{
                  public String name;
                  public Person(){
    
                  }
    
                  public Person(String name) {
                      this.name = name;
                  }
    
                  @Override
                  public String toString() {
                      return "Person{" +
                              "name='" + name + '\'' +
                              '}';
                  }
              }
    
              class Student extends Person{
                  public Student(){
                      this.name="学生";
                  }
              }
              class Teacher extends Person{
                  public Teacher() {
                      this.name="老师";
                  }
              }
    

哪些类型可以有Class对象

  1. class:外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类。
  2. interface:接口
  3. []:数组(多维)
  4. enum:枚举
  5. annotation:注解@interface
  6. primitive type:基本数据类型
  7. void
Linux.md

Linux.md

前提

  • 下好虚拟机后,记得每一次做任务前最好做好快照(血泪的教训)
  • 掌握主机名/IP地址等网络信息配置的方法(一定要保证号网络可用,不然后面吃大亏,下点软件都用不来哦。)

设置IP地址:

  1. 直接在终端运行nmtui命令配置网络(图形界面自己会了)。修改后使用systemctl restart NetworkManager 命令重启,使IP更改信息生效。
  2. nmcli命令配置网络,Ubuntu 通过NetworkManager.service(简称NM)进行网络配置,包括动态和静态IP,因此Ubuntu系统必循开启NM,否则无法使用网络,网络配置存储在/etc/NetworkManager/system-connections/目录中。
  • 用法1:查看IP
    nmcli
  • 用法2:查看connection列表
    nmcli connection show
  • 用法3:修改ens33网卡,配置方式为manual手动,设置静态IP地址,网卡,DNS信息。
  • 用法4;立即生效connection
    nmcli connection up ens33
    nmcli device reapply ens33
    nmcli device connect ens33

快捷键:

  1. Ctrl+Alt+T 组合键打开命令行终端
  2. Ctrl+l 清屏
  3. 打开控制面板的网络适配\连接: Win+R 输入ncpa.cpl
  4. 重启vm虚拟机:reboot

实施SSH远程连接:

  1. 前提Linux中有OpenSSH服务(没有自己下)
  2. 在进行远程登陆前,通过systemctl stop ufwsystemctl disable ufw `关闭防火墙功能。

文件与目录管理:

  • Linux 常用目录功能:
  1. ls(英文全拼:list files): 列出目录及文件名
  2. cd(英文全拼:change directory):切换目录
  3. pwd(英文全拼:print work directory):显示目前的目录
  4. mkdir(英文全拼:make directory):创建一个新的目录
  5. rmdir(英文全拼:remove directory):删除一个空的目录
  6. cp(英文全拼:copy file): 复制文件或目录
  7. rm(英文全拼:remove): 删除文件或目录
  8. mv(英文全拼:move file): 移动文件与目录,或修改文件与目录的名称

系统目录结构:

  1. /bin:
    bin 是 Binaries (二进制文件) 的缩写, 这个目录存放着最经常使用的命令。

  2. /boot:
    这里存放的是启动 Linux 时使用的一些核心文件,包括一些连接文件以及镜像文件。

  3. /dev :
    dev 是 Device(设备) 的缩写, 该目录下存放的是 Linux 的外部设备,在 Linux 中访问设备的方式和访问文件的方式是相同的。

  4. /etc:
    etc 是 Etcetera(等等) 的缩写,这个目录用来存放所有的系统管理所需要的配置文件和子目录。

  5. /home:
    用户的主目录,在 Linux 中,每个用户都有一个自己的目录,一般该目录名是以用户的账号命名的,如上图中的 alice、bob 和 eve。

  6. /lib:
    lib 是 Library(库) 的缩写这个目录里存放着系统最基本的动态连接共享库,其作用类似于 Windows 里的 DLL 文件。几乎所有的应用程序都需要用到这些共享库。

  7. /media:
    linux 系统会自动识别一些设备,例如U盘、光驱等等,当识别后,Linux 会把识别的设备挂载到这个目录下。

  8. /lost+found:
    这个目录一般情况下是空的,当系统非法关机后,这里就存放了一些文件。

  9. /mnt:
    系统提供该目录是为了让用户临时挂载别的文件系统的,我们可以将光驱挂载在 /mnt/ 上,然后进入该目录就可以查看光驱里的内容了。

  10. /opt:
    opt 是 optional(可选) 的缩写,这是给主机额外安装软件所摆放的目录。比如你安装一个ORACLE数据库则就可以放到这个目录下。默认是空的。

  11. /proc:
    proc 是 Processes(进程) 的缩写,/proc 是一种伪文件系统(也即虚拟文件系统),存储的是当前内核运行状态的一系列特殊文件,这个目录是一个虚拟的目录,它是系统内存的映射,我们可以通过直接访问这个目录来获取系统信息。
    这个目录的内容不在硬盘上而是在内存里,我们也可以直接修改里面的某些文件,比如可以通过下面的命令来屏蔽主机的ping命令,使别人无法ping你的机器:

echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all
12. /root:
该目录为系统管理员,也称作超级权限者的用户主目录。

  1. /sbin:
    s 就是 Super User 的意思,是 Superuser Binaries (超级用户的二进制文件) 的缩写,这里存放的是系统管理员使用的系统管理程序。

  2. /selinux:
    这个目录是 Redhat/CentOS 所特有的目录,Selinux 是一个安全机制,类似于 windows 的防火墙,但是这套机制比较复杂,这个目录就是存放selinux相关的文件的。

  3. /srv:
    该目录存放一些服务启动之后需要提取的数据。

16./sys:
这是 Linux2.6 内核的一个很大的变化。该目录下安装了 2.6 内核中新出现的一个文件系统 sysfs 。
sysfs 文件系统集成了下面3种文件系统的信息:针对进程信息的 proc 文件系统、针对设备的 devfs 文件系统以及针对伪终端的 devpts 文件系统。
该文件系统是内核设备树的一个直观反映。
当一个内核对象被创建的时候,对应的文件和目录也在内核对象子系统中被创建。

  1. /tmp:
    tmp 是 temporary(临时) 的缩写这个目录是用来存放一些临时文件的。

  2. /usr:
    usr 是 unix system resources(unix 系统资源) 的缩写,这是一个非常重要的目录,用户的很多应用程序和文件都放在这个目录下,类似于 windows 下的 program files 目录。

  3. /usr/bin:
    系统用户使用的应用程序。

  4. /usr/sbin:
    超级用户使用的比较高级的管理程序和系统守护程序。

  5. /usr/src:
    内核源代码默认的放置目录。

  6. /var:
    var 是 variable(变量) 的缩写,这个目录中存放着在不断扩充着的东西,我们习惯将那些经常被修改的目录放在这个目录下。包括各种日志文件。

  7. /run:
    是一个临时文件系统,存储系统启动以来的信息。当系统重启时,这个目录下的文件应该被删掉或清除。如果你的系统上有 /var/run 目录,应该让它指向 run。

  • 总结:

在 Linux 系统中,有几个目录是比较重要的,平时需要注意不要误删除或者随意更改内部文件。

/etc: 上边也提到了,这个是系统中的配置文件,如果你更改了该目录下的某个文件可能会导致系统不能启动。

/bin, /sbin, /usr/bin, /usr/sbin: 这是系统预设的执行文件的放置目录,比如 ls 就是在 /bin/ls 目录下的。

值得提出的是 /bin、/usr/bin 是给系统用户使用的指令(除 root 外的通用用户),而/sbin, /usr/sbin 则是给 root 使用的指令。

/var: 这是一个非常重要的目录,系统上跑了很多程序,那么每个程序都会有相应的日志产生,而这些日志就被记录到这个目录下,具体在 /var/log 目录下,另外 mail 的预设放置也是在这里。

安装软件的步骤:

  • 以安装gcc为例:
  1. 检查是否安装了gcc
    rpm -qa|grep gcc

  2. 若是没有显示有安装包,则可以用dnf命令安装所需要的软件包,步骤如下:
    mount /dev/cdrom /media

完全背包问题.md

完全背包问题.md

题目:

  • 有 N 种物品和一个容量是 V 的背包,每种物品都有无限件可用。第 i 种物品的体积是 vi,价值是 wi。

求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。

输出最大价值。

输入格式:第一行两个整数,N,V,用空格隔开,分别表示物品种数和背包容积。

接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 i 种物品的体积和价值。

输出格式:
输出一个整数,表示最大价值。

数据范围:
0<N,V≤1000
0<vi,wi≤1000

输入样例
4 5
1 2
2 4
3 4
4 5
输出样例:
10

-题解:

1.二维数组:

import java.util.Scanner;
public class Main{
public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    //读取物品得数量和背包得体积
    int N=sc.nextInt();
    int V=sc.nextInt();
    
    // 分别用于存储物品的体积和价值,数组下标从1开始使用,方便对应物品编号
    int[] v=new int[N+1];
    int[] w=new int[N+1];
    for(int i=1;i<=N;i++){
        v[i]=sc.nextInt();
        w[i]=sc.nextInt();
    }
    //定义一个二维dp数组,通过两层循环来填充dp数组,dp[i][j]表示在前i个物品中,背包容量为j时能获得的最大价值
    int[][] dp = new int[N + 1][V + 1];

    // 初始化边界情况,当没有物品可选(i = 0)时,无论背包容量是多少,最大价值都为0
    for (int j = 0; j <= V; j++) {
        dp[0][j] = 0;
    }
    //核心代码:
    for(int i=1;i<=N;i++){
        for(int j=0;j<=V;j++){
            //如果装得下
            if(j>=v[i]){
                dp[i][j]=Math.max(dp[i][j-v[i]]+w[i],dp[i-1][j]);
            }else{
                dp[i][j]=dp[i-1][j];
            }
        }
    }
    System.out.println(dp[N][V]);
}
}

总结:

01背包问题

01背包问题

题目:

  • 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。第 i 件物品的体积是 vi,价值是 wi。

求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出最大价值。

输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品数量和背包容积。

接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数,表示最大价值。

数据范围
0<N,V≤1000

0<vi,wi≤1000

输入样例
4 5
1 2
2 4
3 4
4 5
输出样例:
8

  • 看会了,就来试一试吧:经典的01背包问题
  • 哈哈哈,祝你的代码状态为:Accepted
  • 要是还不会就看看这几个大佬的视频讲解吧:黑马程序员(多看几遍,多动动手)、代码随想录中的算法公开课
  • 文字版的讲解:代码随想录
  • 题解:创建了二维数组 dp,其中 dp[i][j] 表示在前 i 个物品中,当背包容量为 j 时所能获得的最大价值,通过这样使用二维数组的动态规划方法,全面地考虑了放入和不放入每个物品的各种情况,最终准确地求出满足条件的背包能够装入物品的最大总价值。
  • 代码:

二维数组dp数组

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    // 读取物品数量N和背包容积V
    int N = scanner.nextInt();
    int V = scanner.nextInt();

    // 分别用于存储物品的体积和价值,数组下标从1开始使用,方便对应物品编号
    int[] v = new int[N + 1];
    int[] w = new int[N + 1];
    for (int i = 1; i <= N; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
    }

    // dp[i][j]表示在前i个物品中,背包容量为j时能获得的最大价值
    int[][] dp = new int[N + 1][V + 1];

    // 初始化边界情况,当没有物品可选(i = 0)时,无论背包容量是多少,最大价值都为0
    for (int j = 0; j <= V; j++) {
        dp[0][j] = 0;
    }

    // 动态规划核心逻辑,通过两层循环来填充dp数组
    for (int i = 1; i <= N; i++) {
        for (int j = 0; j <= V; j++) {
            if (j >= v[i]) {
                // 如果背包容量j大于等于第i个物品的体积v[i],可以选择放或不放该物品
                // 取放与不放该物品能得到的最大价值
                dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
            } else {
                // 如果背包容量j小于第i个物品的体积v[i],无法放入该物品,价值与前i - 1个物品时相同
                dp[i][j] = dp[i - 1][j];
            }
        }
    }

    // 输出在前N个物品中,背包容量为V时能获得的最大价值
    System.out.println(dp[N][V]);

}
}

一维数组:

import java.util.Scanner;
public class KnapsackProblemOneDArray {
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    // 读取物品数量N和背包容积V
    int N = scanner.nextInt();
    int V = scanner.nextInt();

    // 分别用于存储物品的体积和价值
    int[] v = new int[N + 1];
    int[] w = new int[N + 1];
    for (int i = 1; i <= N; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
    }

    // dp[j]表示背包容量为j时能获得的最大价值(使用一维数组进行优化)
    int[] dp = new int[V + 1];

    // 动态规划核心逻辑,通过两层嵌套循环来填充dp数组
    for (int i = 1; i <= N; i++) {
        // 注意这里要从V开始逆序遍历到v[i],避免重复使用更新后的数据
        for (int j = V; j >= v[i]; j--) {
            dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
        }
    }

    // 输出背包容量为V时能获得的最大价值
    System.out.println(dp[V]);
 }
}
不同路径I、II-动态规划

不同路径I、II-动态规划

动态规划的理论基础

  • 总结:动态五部曲
    1.确定dp数组(dp table)以及下标的含义
    2.确定递推公式
    3.dp数组如何初始化
    4.确定遍历顺序
    5.举例推导dp数组
    详细来源:代码随想录

不同路径I

  1. 题目:
  • 一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为“Finish” )。问总共有多少条不同的路径?
  1. 公开课:不同路径I
  2. 思路:

-

代码如下:

class Solution {
public int uniquePaths(int m, int n) {
    //定义一个dp的二维数组
    int[][] dp=new int[m][n];
    //初始化dp[i][0]和dp[0][i]
    for(int i=0;i<m;i++){
        dp[i][0]=1;
    }
    for(int i=0;i<n;i++){
        dp[0][i]=1;
    }
    //深推递推公式
   
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = dp[i-1][j]+dp[i][j-1];
        }
    }
     return dp[m-1][n-1];
    
}
}
最大子序和-贪心算法

最大子序和-贪心算法

贪心算法的理论基础

最大子序和

  1. 给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
  • 例如:对于数组 [ -2, 1, -3, 4, -1, 2, 1, -5, 4 ]
  • 它能够找出和最大的连续子数组(子数组是数组中的一个连续部分。在这里是 [ 4, -1, 2, 1 ],其和为 6)
  • 并返回这个最大和的值。
  • Leetcode题目链接

思路

  1. 说实话一开始看到这个题目,脑子的反应就是想用暴力解法,结果一试一试,还真行。哈哈。
  • 思路:暴力解法的思路,第一层 for 就是设置起始位置,第二层 for 循环遍历数组寻找最大值。

代码如下:

class Solution {
public int maxSubArray(int[] nums) {
    int result =Integer.MIN_VALUE;
    int count = 0;
    for (int i = 0; i < nums.length; i++) { // 设置起始位置
        count = 0;
        for (int j = i; j < nums.length; j++) { // 每次从起始位置i开始遍历寻找最大值
            count += nums[j];
            result = count > result ? count : result;
        }
    }
    return result;


}
}
  • 但是时间复杂度:O(n^2)
  • 空间复杂度:O(1),不推荐,还有更好的算法
  1. 那么就是贪心算法(其实也还有其他的解法,例如:dp动态规划)

代码:

class Solution {
public int maxSubArray(int[] nums) {
    if (nums.length == 1){
        return nums[0];
    }
    int sum = Integer.MIN_VALUE; //sum:用于记录在遍历数组过程中找到的最大子数组的和,
    //初始化为 Integer.MIN_VALUE(Java 中 int 类型能表示的最小值),这样可以确保后续在比较和更新最大和时,任何有效的子数组和都能够比初始值大,从而可以正确地更新 sum 的值。
    int count = 0; //count:用于累计当前正在考虑的连续子数组的元素和,初始化为 0,随着遍历数组不断累加元素的值来更新这个累计和
    for (int i = 0; i < nums.length; i++){
        count += nums[i];
        sum = Math.max(sum, count); // 取区间累计的最大值(相当于不断确定最大子序终止位置)
        if (count <= 0){
            count = 0; // 相当于重置最大子序起始位置,因为遇到负数一定是拉低总和
        }
    }
   return sum;
}
}
我的第一篇博客

我的第一篇博客