02, Java gramática básica (promoción automática de tipos de Java, obligatoria conversión de tipo de datos, optimización constante, tabla de códigos ASCII, los operadores aritméticos, operadores de asignación, los operadores relacionales)

Others 2020-03-31 23:03:58 views: null

1, la promoción automática de tipos de Java

2, fundido

3, el mecanismo de optimización constante

4, tabla de códigos ASCII y la codificación del conocimiento

5, como un carácter de mosaico +

6, los operadores aritméticos

7, incremento, operadores decremento

8, el operador de asignación

9, operadores relacionales

1, la promoción automática de tipos de Java

De elevación tipo automático, también llamado tipos de conversión de datos implícitos.

class DataDemo 
{
	public static void main(String[] args) 
	{
		//定义两个byte类型的变量
		byte a = 10;
		byte b = 20;
		
		/*
		byte r = a + b;
		编译错误，不兼容的类型，从int转换到byte可能会有损失
		
		Java中的一个机制：
		自动类型提升：
			当byte、short、char在参与运算时会自动提升为int类型，
		如果还有long、float、double类型参与运算，则会相应的提升为long、float、double类型，
		boolean不参与数学运算，byte、short、char之间不参与转换;
		a b 提升为int类型，结果自然提升为int类型，byte不能接收int类型的结果
		*/
		int r = a + b;
		
		System.out.println("r = " + r); // r = 30

		long c = 1L;
		//r = r + c;
		//编译错误，不兼容的类型，从long转换为int可能会有损失

		long res = r + c;
		
		System.out.println("res = " + res); // res = 31

		float f = 0.1f;

		//res = res + f;
		//编译错误，不兼容的类型，从float转换为long可能会有损失
		//有float类型，long无法存小数

		float result = res + f;
		
		System.out.println("result = " + result); // result = 31.1

		double d = 0.2;

		//result = result + d;
		//编译错误，不兼容的类型，从double转换到float可能会有损失
		double num = result + d;		
		
		System.out.println("num = " + num); // num = 31.3000003814...
	}
}

2, fundido

class DataTypeDemo2 {
	public static void main(String[] args) {
		byte a = 3;
		byte b = 4;
		byte r = (byte) (a + b);
		/*
		强制类型转换：我可以把多余的字节丢弃掉，本来的结果是int类型，四个字节，
		但是我用byte类型来收，那么就可以用强制类型转换，对结果只保留1个字节;

		缺点：有可能发生精度损失
		*/
		System.out.println("r = " + r);
		// r = 7

		byte c = 127;
		byte res = (byte) (a + c);
		System.out.println("res = " + res);
		//res = -126 强制类型转换发生精度损失

		short result = (short) (a + c);
		System.out.println("result = " + result);
		//result = 130
	}
}

130的二进制：

130 = 128 + 2

0000 0000 1000 0010

-126的原码：

126 = 64 + 32 + 16 + 8 + 4 + 2

1111 1110

反码：1000 0001

补码：1000 0010

130在只有一个字节的情况下(byte)130会变为-126。

Salida de carácter visual, los estudiantes dicen c = 30, la declaración de salida de carbón y ninguna salida.

Se puede hacer referencia a la tabla de códigos ASCII

char ch = 65;
System.out.println(ch);
//A 输出可视化字符

3, el mecanismo de optimización constante

class DataTypeDemo3 {
	public static void main(String[] args) {
		byte a = 3;
		//byte r = a + 4;
		//编译错误，有byte类型变量的参与，自动类型提升为int类型

		byte r = 3 + 4;
		//编译成功
		/*
		常量优化机制：当多个常量在参与运算时，它会先把这个结果计算出来，如果在这个类型的范围，
		就不报错；如果不在这个类型的范围，就报错。
		*/
		System.out.println("r = " + r);
        //r = 7
	}
}

4, tabla de códigos ASCII y la codificación del conocimiento

La codificación Unicode: el lenguaje Java utiliza la codificación Unicode, cada carácter es de 2 bytes

Codificación UTF-8: China representó tres bytes de cada

class DataTypeDemo4 {
	public static void main(String[] args) {
		char ch = '我';
		System.out.println("ch = " + ch);
	}
}

El archivo Java en codificación UTF-8.

Unicode是一种字符集(charset)，用两个字节就能囊括世界上所有的文字集合。
UTF-8是一种编码方式(encoding)，是Unicode的一种表现方式。

在一个Java文件(该文件为UTF-8编码)里面写上这样一句话

char a = '猿';
编译后生成的class文件会把'猿'转化成Unicode的两字节。

所以可以编译运行。`javac -encoding utf-8 DataTypeDemo4.java`

Java中的char类型采用utf-16编码，2个字节。

@Test
public void test() {
    char ch = '中';
    System.out.println(Arrays.toString(String.valueOf(ch).getBytes()));
    //[-28, -72, -83]
}

Si la lectura se convierte en una matriz de bytes o un (por defecto del sistema general) utf-8 se convertirá en 3 bytes.

personajes más utilizadas del código ASCII

class DataTypeDemo5 {
	public static void main(String[] args) {
		char ch = 'a';
		char ch2 = ' ';
		int r = ch + 1 + ch2;

		System.out.println("r = " + r);
		// r = 130
		// 'a' = 97, 'A' = 65，'0' = 48
		// ' ' = 32
		//所以：r = 97 + 1 + 32 = 130
	}
}

5, ya que el conector +

package org.westos.demo;


public class MyDemo2 {
    public static void main(String[] args) {
        // + : 1、相加的运算（算术运算符）；2、连接符/拼接符（当+的两侧有任意一边是一个字符串，那么+作为连接符）
        System.out.println(2+3);
        //相加运算，5
        System.out.println(2 + "22");
        //拼接符，222

        System.out.println(20 + 30 + "50");
        //1、相加；2、拼接
        //5050

        System.out.println("100" + 20 + 30);
        //1、拼接；2、拼接
        //1002030

        System.out.println('a' + 5);
        //字符和字符串不同
        //102

        System.out.println("hello" + 'a' + 1);
        //helloa1

        System.out.println('a' + 1 + "hello");
        //98hello，字符在做数学运算时转为数字
    }
}

6, los operadores aritméticos

Operador: constantes y variables símbolos llamados operadores operan.

Categoría del operador:

  • Los operadores aritméticos
  • Operadores de asignación
  • Los operadores relacionales
  • Los operadores lógicos
  • Los operadores bit a bit
  • operador ternario

precauciones:

  • Dos enteros sólo reciben entero división, si decimales desea, utilice un flotador
  • / División de negocios se adquiere operaciones, adquirida% es el resto de una operación de división
  • Símbolo resultados de la operación%, dependiendo del signo de la operación participan la izquierda
package org.westos.demo;


public class MyTest {
    public static void main(String[] args) {
        /* 多行注释：ctrl+shift+/ */
//        单行注释：ctrl+/
        int a = 20;
        int b = 200;
        System.out.println(a+b);
        //220
        System.out.println(a-b);
        //-180
        System.out.println(a/b);
        //0
        System.out.println(a%b);
        //20

        System.out.println(10/3);
        //3
        //两个整数相除只保留整数部分，舍弃小数部分
        System.out.println(10.0/3);
        //3.3333333333333335
        //有double类型参与运算时，3自动提升为double类型

        System.out.println(10%-3);
        //1  10%-3=-3，余1
        System.out.println(-10%3);
        //-1  -10%3=-3，余-1
        //%的结果的正负只与符号左边值的符号有关
        System.out.println(-10%-3);
        //-1
        System.out.println(10%3);
        //1
    }
}

7, incremento, operadores decremento

package org.westos.demo;


public class MyTest2 {
    public static void main(String[] args) {
        int i = 1;
        int j = ++i;
        //先++，再赋值
        System.out.println("i = " + i);
        //i = 2
        System.out.println("j = " + j);
        //j = 2

        int m = 1;
        int n = m++;
        //先赋值，再++
        System.out.println("m = " + m);
        //m = 2
        System.out.println("n = " + n);
        //n = 1
    }
}

Ejercicio:

package org.westos.demo1;


public class MyTest1 {
    public static void main(String[] args) {
        int v = 1;
        int w = 2 + (v++) + 2 - (++v) - 1 - (v--) + 2 - (--v) + 3;
        System.out.println(v);
        //v两次自增两次自减，相当于没有变 1
        System.out.println(w);
        //w = 2 + 1 + 2 - 3 - 1 - 3 + 2 - 1 + 3 = 2
    }
}

A:案例演示
	请分别计算出a,b,c的值?
	int a = 10;
	int b = 10;
	int c = 10;

	a = b++; a=10 b=11
	c = --a; c=9 a=9
	b = ++a; b=10 a=10
	a = c--; a=9 c=8
	
	a=9
	b=10
	c=8

B:案例演示
	请分别计算出x,y的值?
	
	int x = 4;
	int y = (x++) + (++x) + (x*10);
	y = 4 + 6 + 60 = 70
	
	x自增两次，x=6 , y=70

8, el operador de asignación

precauciones:

  • El operador de asignación básica: =
    • Datos = derecho a la asignación de izquierda
  • El operador de asignación extendida: + =, - =, * =, / =,% =
    • + =: La izquierda y derecha para hacer adiciones, y luego asignado a la variable de la izquierda
  • operador de asignación de datos requiere una variable debe dejarse
package org.westos.demo;


public class MyTest3 {
    public static void main(String[] args) {
        //赋值运算符:=,+=,-=,*=,/=,%=
        short s = 1;
        //s = s + 1;
        //编译会报错，short类型变量在运算时自动类型提升为int

        s += 1;
        //这种方式会帮你自动强制类型转换，无论运算结果是否超过short的范围
		
        // 整数之间/结果为整数
        // %的结果只与左侧运算数的符号有关
    }
}

9, operadores relacionales

Los operadores relacionales:

== ,! =, <,>, <=,> =, instanceOf (determina si un tipo de objeto)

precauciones:

  • Ya sea que su funcionamiento es simple o complejo, el resultado es siempre el tipo booleano
  • "==" no se puede escribir en el operador de asignación '='
package org.westos.demo;


public class MyTest4 {
    public static void main(String[] args) {
        int a = 128;
        int b = 200;
        System.out.println(a < b);
        //true

        String str = "abc";
        System.out.println(str instanceof Object);
        //true 判断是否是某个类型的对象
    }
}

Supongo que te gusta

Origin www.cnblogs.com/shawnyue-08/p/12609334.html
Recomendado
Clasificación
Diario
Más
2024-04-28(9)
2024-04-27(28)
2024-04-26(22)
2024-04-25(34)
2024-04-24(31)
2024-04-23(29)
2024-04-22(5)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)

Code World

© 2018 codetd.com