zoukankan      html  css  js  c++  java
  • java----基础

     java基础:

    JDK:java开发环境,包含了java运行环境JRE,java工具以及基础类库。

    JRE:java运行环境,大家熟知的JDK不同,JRE是Java运行环境,并不是一个开发环境,所以没有包含任何开发工具(如编译器和调试器),只是针对于使用Java程序的用户。

    添加环境变量

    JVM:.class文件并不直接与机器的操作系统相对应,而是经过虚拟机间接与操作系统交互,由虚拟机将程序解释给本地系统执行。只有JVM还不能成class的执行,因为在解释class的时候JVM需要调用解释所需要的类库lib,而jre包含lib类库。

    cavaj java decompiler     https://cavaj-java-decompiler.en.softonic.com/    java 反编译工具     如果java字节码 进行了加密,就没有用了

    javac   hellow.java           // 编译代码  为.class  java字节码
    javac -d . HelloWord.java     //如果HellowWord.java中有包名,如果需要将包也构建出来,可以使用这个命令
    java    hellow                //运行代码
    javadoc Hellowold.java        //生成文档

    Helloword  代码

    /**
           文档注释
    */
    public class Hellowold{
    	/*
    		多行注释
              Sting[]   为字符串数组
              args      字符串数组的名字
         */
    	//	单行注释
    	public static void main(String[] args){
    		System.out.println("hello word!"); 		
    	}
    }

    java中八种数据基本类型

      这些变量在方法体中必须要定义和初始化,才可以使用

              占字节   默认值
    int	Integer	    4	   0
    short	Short	    2	  0
    long	Long	    8	  0l或0L
    byte	Byte	    1	  0
    float	Float	    4	  0.0F或0.0f
    double	Double	    8	  0.0
    char	Character   2	  u0000
    boolean	Boolean	  1位(不是一个字节) false
    

      整形变量:011(以0开头的表示8进制),0x11(以0x开头的表示16进行) ,0b11(以0b开头的表示2进制),默认类型是int,比如byte a=11;(11是int类型,被转换了byte)

      浮点变量:float尾数可以精确到7位。double:约是float的两倍,默认是dubbo类型,比如float a = 3.14;(会报错,3.14是dubbo类型,用float放不下,所以写3.14F,将3.14转换成float类型),浮点数一般用来比较,比如float a=111111111,float b=111111112,这两个数如果相比较就是true(浮点数是从第一个不为0的数往后数x位来进行比较,在往后面的数据就忽略了),如果需要比较浮点数或者非常大的整数,可以使用java.math包下面的两个有用的类:BigInteger和BigDecimal,这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。

    java中引用数据类型

      string、数组、接口、类等,占用4个字节(引用对象的地址)

    char chr = 127;
    int sum = 200;
    chr += 1;
    sum += chr;
    后,sum的值是? 答案:72和328
    备注:同时考虑c/c++和Java的情况的话
    
    解释:
    java中只有byte, boolean是一个字节, char是两个字节, 所以对于java来说127不会发生溢出, 输出328 
    但是对于c/c++语言来说, char是一个字节, 会发生溢出, 对127加一发生溢出,  0111 1111 --> 1000 0000, 1000 0000为补码-128, 所以结果为200-128=72
    

     基本数据类型转换 (自动转换):

    public class Demo {
    
    	public static void main(String[] args) {
    		byte a = 10;
    		short b = a;
    		int c = b;
    		long d = c;
    		
    		float y = 11;
    		double z = y;
    		
    		//float double 属于近似值
    		//byte short int  属于精确值
    		
    		//精确值转换近似值 ,不需要强制转换,可能会丢失精度
    		
    		int num1 = 21323123;
    		float num2 = num1;   //赋值表示将 整数 21323123 赋值给了num2,类似num3
    		
    		float num3 = 21323123;
    		System.out.println(num2);   //2.1323124E7
    		System.out.println(num3);   //2.1323124E7
    }
    }  

    注意:byte short int 计算时,自动转换 int 类型来比较大小

    报错
    short t1 = 10;
    t1 = t1 + 1;  // 1 为 int 类型; t1为 short 类型 不能接受 int 类型  ,改为int t2 = t1 + 1 即可
    System.out.println(t1);
    即使,两个 short 类型相加,同样会报错
       short t2 = 1;
       short t1 = 10;
     t1 = t1+ t2;  //自动转换为 int 类型 
    
    没有报错
    short t1 = 10;
    t1 += 1;
    System.out.println(t1);
    
    没有报错
    int t1 = 10;
    t1 = t1 + 1;
    System.out.println(t1);
    
    
    

    解决:强制转换

    short t2 = 1;
    short t1 = 10;
    t1 = (short)(t1 + t2);  // t1为 short类型接受,将t1+t2,强制转变为short类型  int t3 = (short)(t1+t2),可以,int 本身就可以接受 short 类型的数据
    System.out.println(t1);

    补充

    String  不是基本数据类型 是引用类型变量,32位系统占4个字节,64位占8个字节,对于h = new Horse(); h也是引用类型变量,站的空间是所有属性占的空间之和
    String x = "sdfdsf";  //接受一个字符串
    char   x = 'd';          //接受一个字符
    
    注意:不能使用同一个局部变量,否则会自动转换,如果遇到不能转换的就会报错

     java运算:

     public class Demo {
    
    	public static void main(String[] args) {
    		int x=1;
    		int y=2;
    		y = x+y-(++y);          //从前往后执行,并不是先 执行括号里面的 
    		System.out.println(x);  //1
    		System.out.println(y);  //0;如果(y++)-->1
    }
    }  

    总结

    public class Test {
        public static void main(String[] args) {
     
            //数据比较注意问题
            int a =111111;
            Integer b =111111;
            System.out.println(a==b); //true Integer和int比较的时候,会将Integer拆成int类型
     
            Integer c =111111;
            System.out.println(b==c); //false b和c两个对象不一样
     
            b = 127;
            c = 127;
            System.out.println(b==c); //true 此时b和c两个对象一样,Integer在-128<= x<=127的整数,将会直接缓存在IntegerCache中。(IntegerCache会缓存一个字节一下的整数)
     
            b = new Integer(127);
            c = new Integer(127);
            System.out.println(b==c); //false 此时b和c两个对象都是两个新的对象
     
            b = new Integer(127);
            Integer d = 127;
            System.out.println(b==d); //false b创建的对象是存放在堆中,和IntegerCache缓存中的d不一样
     
            b = 128;
            d = 128;
            System.out.println(b==d); //false IntegerCache不能存放128,所以b和d都相当于new Integer(128)
     
            //总结:凡是new Integer(xx),则这两个数肯定是不一样的;
            //如果使用int=xx,那这两个数肯定是一样的
            //如果使用Integer=xx,如果-128<=xx<=127,则这两个数是一样;
     
            float x = 11111f;
            float y = 11111f;
            System.out.println(x==y); //true
     
            Float z = 1f;
            Float w = 1f;
            System.out.println(z==w);//false,浮点数不像Integer一样了
     
     
            //基本数据类型转换注意问题;
            long aa = 11L;
            int  bb = (int)(aa);
            Long cc = 11L;
            //int bb = (int)(cc) 不能转换,cc此时是Long对象了
             
            //基本数据类型相加
            int s1=1;
            int s2=2;
            int s3 = s1+s2-(s2+++1+s2++);
            System.out.println(s1);  //1
            System.out.println(s2);  //4
            System.out.println(s3);  //-3
     
            int a1=1;
            int a2=2;
            int a3 = a1+a2-(a2+++1);
            System.out.println(a1);  //1
            System.out.println(a2);  //3
            System.out.println(a3);  //0
     
            int b1=1;
            int b2=2;
            int b3 = b1+b2-(b2+++1+b2);
            System.out.println(b1);  //1
            System.out.println(b2);  //3
            System.out.println(b3);  //-3
             
            int c1=1;
            int c2=2;
            int c3 = c1+c2-((c2++)+1+c2++)+c2+c2++;
            System.out.println(c3);//5
            int t = c2++;
            System.out.println(t);//5        
        }
    }
    

      

            //赋值的时候是从前往后赋值,赋值的操作不会改变前面已经赋值的操作,运算是先算括号中的
            int a2=2;
            //int a3 =  (++a2)+a2;                   //a3=6
            //int a3 =  a2+(++a2);                   //a3=5
            //int a3 = a2-(++a2+(++a2));             //a3=-5
            int a3 = a2-(++a2+(++a2))+ a2++ + (++a2);//a3=5
            System.out.println(a3);
            System.out.println(a2);

     java运算符

     位运算 

         

    >> 带符号右移位

      正数移位:右边(低位)移出部分,直接舍弃,左边(高位)移入部分全部补0。(正数的符号为是0)

           负数移位:右边(低位)移出部分,直接舍弃,左边(高位)移入部分全部补1。(负数的符号为是1)

    << 带符号左移位

      左边(高位)移出部分,直接舍弃;右边(低位)移入部分全部补0。

    >>> 无符号右移位

      对于正数和0,无符号右移位>>>和带符号右移位>>,结果是一样的

      负数移位:右边(低位)移出部分,直接舍弃,左边(高位)移入部分全部补0。(符号为由1变成0,所以负数变正数)  

     注:java没有 <<< 因为 <<< 就等于 <<

    import java.util.Scanner;; 
    public class Demo {
    	public static void main(String[] args) {
    //以最快的速度进行 64 乘 *8                   //64*8=512 速度不够快,位移运算速度最快
    		short x = 64;  
    		System.out.println(x<<3);  //512                      左移运算   6<<x -->6*2(进制)的x次方  速度最快
              System.out.println(-x<<3); //-512                              -6<<x   -6*2**n
    		System.out.println(x>>3);  //8                        右移运算   6>>x -->6/ 2(进制)的x次方
    		System.out.println(-x>>3); //-8                       右移运算   -6>>x -->-6/ 2(进制)的x次方
    		System.out.println(x>>>3); //8                        右移运算   6>>>x -->6/ 2(进制)的x次方(正数>>>相当>>  负数>>> 会变成正数且不等于>>)
    		System.out.println(-x>>>3);//536870904左移运算         没有公式
    		//结果 short int byte 都是 以 int 4个字节运算
    	}
    }  
    

    注意,如果移动的位数足够大,上面的公式就不管用了,如15<<27= 2013265920 ,15 <<28 = -268435456

                              15<<32 = 15, 15 << 33 = 30

    &做位运算时

    A = 0011 1100   == 60
    B = 0000 1101
    -----------------
    A&b=0000 1100
    A|B=0011 1101
    A^B=0011 0001          异或,相同的为false,不相同的为true
    ~A= 1100 0011          == -61的补码; ~x=-x

    &做逻辑运算时

    import java.util.Scanner;; 
    public class Demo {
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		boolean x = true;
    		boolean y = false;
    		boolean z = x&y;
    		System.out.println(z); 
    	}
    }  

    &的一个重要的用法就是(2x-1)&任何数都是小于(2x-1),比如15--->00000.....1111(二进制)

    000000......1111

    101001......1011

    ---------------------------------------

    000000......1011  <1111

    逻辑运算符

    注意

     &分别需要计算两边的值;在做判断,效率低;

     && 先计算左边的值,如果为false,直接返回false,效率高

    | 和 ||  同理;

     if分支语句:

    if(){
    
    }else if(){
    
    }else{
    }
    
    if(x==10)--->最好写成if(10==x)   //用一个确定的值和不确定的值进行对比, 原因x可能为空,出现空指针的异常

     switch分支语句:

    //进行两个数据的调换位置
    import java.util.Scanner;
    public class Demo {
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		int n = input.nextInt();
    		switch(n){
    		case 1:{
    			System.out.println("星期一");
    			break;
    		}
    		case 2:{
    			break;
    		}
    		default:{
    			System.out.println("没有");
    			break;
    		}
    		};
    		System.out.println("结束");
    	}
    }
    
    注意jdk 1.7之前不支持 String 即case “sdf”,在1,7之后,支持,原理是编译器在编译的时候将字符串转变成哈希值,int数 case是可以匹配的

    注意:如果一旦case相应的值成功,但内部没有break语句,那么将会无条件(不再进行case匹配)的继续向下执行其它case中的语句,直到遇到break;语句或者到达switch语句结束 

     循环语句:

    while(){
          }
    ==================
    int i=1;
    do{
      System.out.println("先执行一遍");
      i++;
    }while(i<=10);
    
    =================
    
    for(;;){
      System.out.println("111");  //死循环
    }
    
    for(int i=0;;i++){      //只要中间没有判断,即为死循环
      System.out.println("111");
    }

    跳出多重循环

        public static void main(String[] args) {
            ok:
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 10; j++) {
                    break ok;
                }
            }
        }

    例题:

    //进行两个数据的调换位置
    public class Demo {
    	public static void main(String[] args) {
    		
    		int a=2;
    		int b=3;
    		//方法一
    //		int t = a;
    //		a = b;
    //		b = t;
    		
    		//方法二:
    //		a = a+b;
    //		b = a-b;
    //		a = a-b;
    		
    		
    		//方法三:
    //		a = a+b-(b=a);
    		
    		//方法四  速度最快  注意,a 和 b 不能为 同一个 值  否则 a^b =0
    		a = a^b;
    		b = a^b;
    		a = a^b;
    		System.out.println("a="+a+",b="+b);
    	}
    }
    

      

  • 相关阅读:
    [Functional Programming] Building a Timer UI by Composing Callbacks
    [Debug] Use Chrome DevTools console utilities to make debugging easier
    [Debug] Copy a network request as fetch or cURL with Chrome DevTools
    [CSS] Use CSS Variables with Calc and HSL to Implement Dark Mode
    [Kotlin] Adding functions to existing classes (extension functions)
    [Kotlin] Unit testing throws exception
    [Kotlin] Try resource, use {} block
    少儿编程教学环境开发之架构选型篇
    分布式系统理论之Quorum机制
    存储基本概念(lun,volume,HBA,DAS,NAS,SAN,iSCSI,IPSAN)
  • 原文地址:https://www.cnblogs.com/yanxiaoge/p/10639141.html
Copyright © 2011-2022 走看看