javaDay02.md

Others 2020-04-13 22:56:55 views: null

Operador (1-4 puntos clave para dominar)

  1. Operadores aritméticos: +, -, *, /,%, ++, -
  2. Operador de asignación: =
  3. Operadores relacionales:>, <,> =, <=, == ,! = Instanceof
  4. Operadores lógicos: &&, ||,!
  5. Operadores a nivel de bits: &, |, ^, ~, >>, <<, >>> (entiendo !!!)
  6. Operadores condicionales:?,:
  7. Operadores de asignación extendida: + =, - =, * =, / =
        //二元运算符
        //ctrl+D :复制当前行到下一行

        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

long a = 122222222222222222L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d);  //long
        System.out.println(b+c+d);  //int
        System.out.println(c+d);  //int

//关系运算符返回的结果：正确，错误   布尔值

        int a = 10;
        int b = 20;
        int c = 22;

        System.out.println(c%b);  //取余   
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);

Operador de auto-incremento y decremento

//++  --   自增   自减
        int a = 3;
        int b = a++;  //执行完这行代码后，先给b赋值，再自增
        //a++  a = a + 1
        System.out.println(a);

        int c = ++a; //执行完这行代码后，先自增，后赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

//幂运算
        //使用工具类来操作
        double pow = Math.pow(2,3);
        System.out.println(pow);

Operador lógico

    //逻辑运算符
        //与(and)  或（or）  非（取反）

        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a && b));//逻辑与，两个变量都为真，结果才为true
        System.out.println("a || b :"+(a || b)); //逻辑或，两个变量有一个为真，则结果才为true
        System.out.println("! (a && b):"+!(a && b)); //逻辑非，如果为真，则变为假


        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);//逻辑与，如果c<4为假，就不会执行c++<4;
        System.out.println(d);
        System.out.println(c); //c的值为5

Operación de bits

 /*
      * A = 0011 1100
      * B = 0000 1101
      *
      * A&B = 0000 1100  //全1为1，有0为0
      * A|B = 0011 1101  //全0为0，有1为1
      * A^B = 0011 0001  //相同为0，不同为1
      * ~B  = 1111 0010  //取反
      *
      *
      * */

      //2*8=16   2*2*2*2
      //效率极高！！！
      //<<  *2
      //>>  /2
      /*
       0000 0000    0
       0000 0001    1
       0000 0010    2
       0000 0011    3
       0000 0100    4
       0000 1000    8
       0001 0000    16
       */
        System.out.println(2<<3); //16

Operador ternario y resumen

  int a = 10;
        int b = 20;

        a += b;  //a = a + b

        System.out.println(a);

        //字符串连接符   +  ,String
         
        System.out.println(""+a+b); //3020
        System.out.println(a+b+"");  //50

 //三元运算符
        //x ? y : z
        //如果x==true,则结果为y,否则结果为z

        int score = 80;
        String type = score < 60 ?"不及格":"及格"; //必须掌握
        //if
        System.out.println(type);

Mecanismo de paquete

package pkg1[. pkg2[. pkg3……]];

Generalmente use la inversión del nombre de dominio de la compañía como el nombre del paquete:

com.baidu.www

Para poder utilizar los miembros de un determinado paquete, necesitamos importar explícitamente el paquete en el programa Java. Use la declaración "import" para completar esta función

import package1[.package2……].(Classname|*);

package com.kuang.operator;

import com.kuang.operator.*; //导入全部  *为通配符

javadoc

El comando javadoc se usa para generar su propia documentación de API

Información de parámetros

  1. @autor nombre del autor
  2. Número de versión de @version
  3. @since indica que se requiere la primera versión de jdk utilizada
  4. Nombre del parámetro @param
  5. @ valor de retorno de retorno
  6. @ arroja excepción lanzada
package com.kuang.operator;

/**
 * @author Hao
 * @version 1.0
 * @since 1.8
 */



public class Demo10 {
    String name;


    /**
     * @author Hao
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
    //通过命令行   javadoc 参数 java文件
    //面向百度编程
    
}

control de flujo de java

  1. Escáner de interacción del usuario
  2. Estructura secuencial
  3. Seleccionar estructura
  4. Estructura cíclica
  5. romper y continuar

Objeto escáner

Obtenga la entrada del usuario a través de la clase Scannery

Sintaxis básica:

Scanner s = new Scanner(System.in);

import java.util.Scanner;

public class Demo3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入字符串：");

        String str = scanner.nextLine();

        System.out.println("输入的内容为："+str);
        scanner.close();
    }

}

La cadena de entrada se obtiene mediante los métodos next () y nextLine () de la clase Scanner. Antes de leer, generalmente necesitamos usar hasNext () y hasNextLine () para determinar si hay datos de entrada.

next () hasNext ()
  1. La entrada debe completarse después de leer los caracteres válidos
  2. El método next () eliminará automáticamente los espacios en blanco encontrados antes de ingresar caracteres válidos.
  3. Solo después de ingresar un carácter válido puede el espacio ingresado después de ser utilizado como separador o terminador
  4. next () no puede obtener una cadena con espacios
import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {

        //创建一个扫描器对象，用于存放键盘收据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方法接受：");

        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            String  str = scanner.next();  //程序会等待用户输入完毕
            System.out.println("输出的内容是："+str);

        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
        scanner.close();


    }
next () hasNextLine ()
  1. Con Enter como el carácter final, el método NextLine () devuelve todos los caracteres antes de ingresar el retorno de carro.
  2. Ponerse en blanco
import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于存放键盘收据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方式接收：");

        //判断用户有没有输入字符串
        if (scanner.hasNextLine()){
            //使用nextLine方式接收
            String str = scanner.nextLine();
            System.out.println("输入的内容为："+str);
        }

        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
        scanner.close();
    }

Uso avanzado de escáner

import java.util.Scanner;

public class Demo4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);


        //从键盘接收数据
        int i = 0;
        float f = 0.0f;

        System.out.println("请输入整数：");

        if (scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据："+i);

        }else {
            System.out.println("输入的不是整数数据！");

        }
        System.out.println("请输入小数：");
        if (scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据："+f);
        }else {
            System.out.println("输入的不是小数数据！");
        }

Practica

import java.util.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数字：");
        //和
        double sum = 0;

        //计算输入了多少个数字
        int i = 0;
        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while (scanner.hasNextDouble()) {
            double x = scanner.nextDouble();
            i = i + 1;  // i++
            sum = sum + x;
            System.out.println("你输入了第"+i+"个数据，当前结果sum="+sum);
        }
        System.out.println("这"+i+"个数字的和是："+sum);
        System.out.println("这"+i+"个数字的平均值是："+(sum/i));

        scanner.close();
    }

}

Estructura secuencial

  1. La estructura básica de Java es una estructura secuencial . A menos que se especifique lo contrario, se ejecutará frase por frase en orden.
  2. La estructura secuencial es la estructura de algoritmo más simple.
  3. Es una estructura de algoritmo básica indispensable para cualquier algoritmo.

Seleccionar estructura

  1. si estructura de selección única
  2. si estructura de doble selección
  3. si estructura de opción múltiple
  4. Anidado si estructura
  5. cambiar la estructura de selección múltiple

si estructura de selección única

Sintaxis:

if(){
    //如果布尔表达式为true将执行的语句
}

​

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        // equals()判断字符串是否相等
        if (s.equals("Hello")){
            System.out.println(s);

        }
        System.out.println("End");
        scanner.close();
    }

si estructura de doble selección

Sintaxis:

if(布尔表达式){
    //如果布尔表达式的值为true
}else{
    //如果布尔表达式的值为false
}

import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args) {
        //考试分数大于60分就是及格，小于60分就不及格
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score  = scanner.nextInt();

        if (score>60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }

        scanner.close();
    }
}

si estructura de opción múltiple

Sintaxis:

if(布尔表达式1){
    //如果布尔表达式1的值为true执行代码
}else if(布尔表达式2){
    //如果布尔表达式2的值为true执行代码
}else{
    //如果以上布尔表达式都不为true执行代码
}

import java.util.Scanner;

public class Demo3 {
    public static void main(String[] args) {
        //考试分数大于60分就是及格，小于60分就不及格
        Scanner scanner = new Scanner(System.in);
        /*
        if 语句至多有1个else语句，else 语句在所有的 else if 语句之后。
        一旦其中一个 else if 语句检测为 true， 其他的 else if 以及 else 语句都将跳过执行。
         */
        
        
        System.out.println("请输入成绩：");
        int score  = scanner.nextInt();

        if (score==100){
            System.out.println("S级");
        }else if (score<100 && score>=90){
            System.out.println("A级");
        }else if (score<90 && score>=80){
            System.out.println("B级");
        }else if (score<80 && score>=70){
            System.out.println("C级");
        }else if (score<70 && score>=60){
            System.out.println("D级");
        }else if (score<60 && score>=0){
            System.out.println("不及格");
        }else{
            System.out.println("成绩不合法！");
        }


        scanner.close();

    }
}

Anidado si estructura

Sintaxis:

if(布尔表达式 1){
    ////如果布尔表达式 1的值为true执行代码
    if(布尔表达式 2){
        ////如果布尔表达式 2的值为true执行代码
    }
}

cambiar la estructura de selección múltiple

Los tipos de variables en la declaración de cambio pueden ser:
  1. byte 、 corto 、 int 或 char
  2. el interruptor admite el tipo de cadena
  3. la etiqueta del caso debe ser una constante de cadena o un literal

Sintaxis:

switch(expression){
    case value :
        //语句
        break;  //可选
    case value :
        //语句
        break;  //可选
    //你可以有任意数量的case语句    
    default :  //可选
        //语句
    
}

public class Demo4 {
    public static void main(String[] args) {
        // case穿透（无break）   //switch 匹配一个具体的值

        char grade = 'F';
        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("中等");
                break;
            case 'D':
                System.out.println("及格");
                break;
            case 'E':
                System.out.println("不及格");
            default:
                System.out.println("未知等级");

        }
    }
}

Código 01

package sturct;

public class Demo5 {
    public static void main(String[] args) {
        String name = "小明";

        //字符的本质还是数字
        //反编译  java---class(字节码文件)-------反编译（IDEA）

        switch (name){
            case "小明":
                System.out.println("小明");
                break;
            case "孙悟空":
                System.out.println("孙悟空");
                break;
            default:
                System.out.println("弄啥嘞！");
        }
    }
}

Código 02 (código descompilado)

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package sturct;

public class Demo5 {
    public Demo5() {
    }

    public static void main(String[] args) {
        String name = "小明";
        byte var3 = -1;
        switch(name.hashCode()) {
        case 756703:
            if (name.equals("小明")) {
                var3 = 0;
            }
            break;
        case 23271124:
            if (name.equals("孙悟空")) {
                var3 = 1;
            }
        }

        switch(var3) {
        case 0:
            System.out.println("小明");
            break;
        case 1:
            System.out.println("孙悟空");
            break;
        default:
            System.out.println("弄啥嘞！");
        }

    }
}

Estructura cíclica

  1. mientras bucle
  2. hacer mientras bucle
  3. para bucle
  4. Java5 presenta un bucle for mejorado utilizado principalmente para matrices

mientras bucle

Sintaxis:

while(布尔表达式){
    //循环内容
}
  1. Mientras la expresión booleana sea verdadera, el bucle continuará ejecutándose.
  2. En la mayoría de los casos detendremos el ciclo, necesitamos una forma de invalidar la expresión para finalizar el ciclo.
  3. Un pequeño número de situaciones requiere que el bucle se ejecute todo el tiempo, como el monitoreo de respuesta de solicitud del servidor.
  4. Si la condición del bucle siempre es verdadera, causará un bucle infinito [bucle inactivo]. En la programación comercial normal, trate de evitar un bucle infinito. Afectará el rendimiento del programa o hará que el programa se congele y se bloquee.
package sturct;

public class Demo6 {
    public static void main(String[] args) {
        //输出1~100
        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
        }

    }
}

package sturct;

public class Demo7 {
    //死循环
    public static void main(String[] args) {
        while (true){
            //等待客户端连接
            //定时检查
            //。。。。。
        }
    }
}

Practica

package sturct;

public class Demo8 {
    public static void main(String[] args) {
        //计算1+2+3+……+100=？
        //高斯的故事
        int i = 0;
        int sum = 0;

        while (i<=100){
            sum = sum + i;
            i++;
        }
        System.out.println(sum);
    }
}

Supongo que te gusta

Origin www.cnblogs.com/Mr-Sunday/p/12694306.html
Recomendado
Clasificación
Diario
Más
2024-05-20(5)
2024-05-19(0)
2024-05-18(30)
2024-05-17(4)
2024-05-16(22)
2024-05-15(5)
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)

Code World

© 2018 codetd.com