【java】理解对象后面的一些知识点

1.注意：

 src.zip（java核心类文件 源代码）-----》rt.jar（.class文件，核心类库中的一个）

1.1.找零问题：解决精度丢失问题

BigDecimal类：
例如：BigDecimal a=BigDecimal.valueOf（5.689524）;
BigDecimal a=BigDecimal.valueOf（5.689524）.subtract（BigDecimal.valueOf（5.689524））//相减

1.2，长整除问题：

BigInteger类：
	例如：BigInteger a=BigInteger.valueOf(158888888888888888888888);
	BigInteger a=BigInteger.valueOf(1588).multiply(BigInteger.valueOf(158888);)//相乘

2.理解对象

面向过程：c
		面向对象编程：c++，java
			遇到问题找对象，让对象调用方法去解决
			如果没有类似功能对象，自己定义类，进而实例化对象
			public static void main（String[] args）{
				实例化对象
			}
1.对象：
2.类：对属性，功能，相似的一类对象归纳总结他们的共同特点，得到相应的类，【类型，用户自定义类型】
			类是对象的抽象，对象是类的具体实例

2.类是用户自定义的类型

定义格式
				[public] class 类名{
					[权限修饰符] 数据类型 成员变量名
					.....
					[public ] 返回值类型 方法名（形参列表）{
						方法的具体实现
					}		
				}

3.如何用类实例化一个对象

			格式：
				类类型 对象名 =new 类名（）；
				student s1=new student（）；

4.引用数据类型

				类：class
				接口：interface
				数组：[]

5.变量

1.局部变量（在代码块{}中定义的变量，其作用范围只在{}内部）
局部变量对应内存上 栈空间 一块内存区域，一旦使用完成【出作用范围】，自动被销毁
	函数帧:每一个函数运行，都会开辟一块空间，保证其正常运行。
		1.形参对应的内存区域
		2.主调函数基地址；
		3.内部定于局部变量；使被调函数执行完后回到mian方法中
		4.下一条执行的指令
2.实例变量（类的成员变量）
		类成员变量依赖对象存在，只有new对象以后，

二、操作符

1.赋值操作符

1.= *= += -=  /= %=....
	++	自增 
	--	自减
		a++ 表示先使用a的值进行操作或者运算，然后再让a完成自增1
		++a 表示先让a完成自增1，然后再使用a的值进行操作或者运算
		--同理
2.引入：
	左值: 表示对应内存空间  
    右值：表示空间中数据值	
		int a = 10;	//左值
		int b = 5;	//左值
	    a = b;		//a: 左  b: 右
		syso(a);	//a: 右
		a++;	//左、右

2.比较操作符

> < >= <= 
instanceod:判断指定的对象是否属于另一个指定的类型
例如：Person o = new Person(); //表示引用o所指向的对象，是不是属于Person类型
	  System.out.println( o instanceof Person );//会输出true或者false

3.相等操作符

		==，！=

4.移位操作符；对二进制操作

4.1.左移：本质上左移一次为2,左移两次为2*2

	int a = 10;	//0 0(23) 00001010
	//左移: a往左移动3位
	int b = a << 3;------->0 0(23) 00001010====>0 0（23）01010000 // 80
-10： 
	0 0(23) 00001010
原	1 0(23) 00001010
反  1 1(23) 11110101
补  1 1(23) 11110110
	
-10 << 3; 
补	1 1(23) 10110000
反  1 1(23) 10101111
原  1 0(23) 01010000//-80

4.2.右移：本质上右移一次为/2,右移两次为/2/2

a = 10；
a >> 2;
0 0(23) 00001010
右移补符号位的值
000 0(23) 00000010	

6.位操作符

& 与 ：两个一得一（用来将某一位置为0）

int b = ~(1 << (n-1)) & a;  //将v变量值 的 第n位置为0，然后返回结果值

public int setBit(int v,int n) {
       int t = ~(1 << (n-1)) & v;
		return t;
	}	

| 或 ；有一得一（用来将某一位置为1）

^ 异或 ：相同为0，不同为1

 （一个数异或另一个数两次，结果还是它自己）
例如：int a=10;
	       int b=3;
	       //交换ab的值：a=a^b;
					    b=a^b;
						a=a^b;
		~ 取反 ：按位取反
	**

7.逻辑运算符

1.&& &：短路与：

有一个为假整个条件都为false；即true && true=true；

例如：if(表达式1 && 表达式2) {
	     2个条件同时满足，则执行该代码
	 }

2.||、 | 逻辑或

只要满足其中一个，则为true
	      true || ? ==> true 

3.逻辑非！

8.条件运算符

也称三目运算符
表达式1 ？变量1？变量2：若表达式1为true 则返回变量1；为false 返回变量2；

三、类型转换：

1.基本数据类型转换

		1.隐式转换：
			是数据范围比较小的，自动就可以转换为数据范围比较大的类型（基本类型）
			例如：byte a=1；
				int b=a；//隐式转换，自动转化为大类型int
		2.显示转换
			手动转换：int a=100；byte b=a；//编译报错，
				  byte b=（byte）a；手动转换；
				  
		3.浮点数类型，如果强转为整型，小数部分会全部抹去；
			Math.random()返回[0,1)的随机数，类型是double

2.引用类型转换：

		1.隐式转换：	
			student s=new student（）；
			object 0=s；
			//上面两句代码合成下面一句代码
			object 0=new student（）；子类类型的变量可以自动转换（隐式）父亲类型
		2.显式转换：
			object 0=new student（）；
			student s=（student）0；
			//父亲类型的变量，需要强制转换为（显式）子类类型；

四、java语句：

1.控制语句：if语句

1.
	if（条件表达式）{
		表达式成立之后执行的语句体
	  }
2.
	if（表达式1）{
		表达式1成真的执行语句体
	  }else{
		表达式1不成立执行的语句体
	  }
3.
if（表达式1）{
		语句体1；
	  }else if（表达式2）{
		语句体2；
	  }else if（表达式3）{
		语句体3
	  }
	  ....
	  else{
		语句体n
	  }
	  //最后的else语句可以不写l；

2.分支语句switch case

1格式：	
switch（表达式）{
		case 值1 ：执行的语句；
		           break; 
	    case 值2：语句体2; break; …
		default：
		语句体n+1; break;
	}
	//然后和case后面的匹配，如果有就执行对应的语句，否则执行 default控制的语句


2.switch表达式可以接收的值：
	//基本数据类型可以接收byte char short int case 值1：
	//引用数据类型可以接收枚举JDK1.5，字符串JDK1.7
	
3.注意：case后面只能跟常量，不能跟变量，多个case后跟的值不能相同 
	      default语句可以省去，但建议保留 l break可以省去，但建议保留，因为省去break,case会穿透执行
		  default最好放到最后，但可以放在其他地方 
		  switch遇到以下任一条件结束：break,右大括号

3.循环控制语句：

3.1.for循环

1.结构
   for（初始化语句1；条件表达式2；循环后的操作表达式）{
	  循环体；
 	}
	
    例如；	求水仙花数

               int g;s;b;
				for(int i=1;i<=999;i++){
					g=i%10;
					s=i/10%10;
					b=i/100;
			
					if(i==(g*g*g)+(s*s*s)+(b*b*b)){
						System.out.println("水仙花数： "+i);
					}
				}

2.补充：1.初始化语句1可以为空；【循环前已经完成初始化】
		2.循环判断条件一般不能省去
		3.循环后的语句一般不能省去，但是可以放入循环体中；
		4.每次执行都离结束条件更近；
		5.for（；；）{}：死循环；

3.2.while语句【无明确循环次数】

		while(判断条件语句) { 
			条件成立循环体语句; 
		    控制条件语句;
		}
		与for循环的区别：1.for循环可以确定循环的次数；

3.3. do…while

   【while可能一次都不执行，若使用do..while循环至少能执行一次】

		生成[min ,max]范围内的随机数
			（int）（Math.random（）*（max-min+1））+min
		例如：生成一个10到45的随机数，如果随机数是3和5和公倍数，则结束运行；

               int a；
				do{
					a=（int）（Math.random（）*（45-10+1））+10；
					syso（a）；
				}while（a%3！=0 || a%5！=0）{
					syso(a);
				}

注意：
    1.两种死循环：while(true){...} ； for(;;){...}
	2.while（true）;{.....}//用；隔开不会执行到{}里面的内容，一次都不执行
	3.for(.....);{.....}//用；隔开，{}里面的内容只会执行一次，

4.两个关键字：

break ：用在循环体内部，作用是结束整个循环 
continue ：用于循环体内部，作用是结束本次循环，进入到下一次循环

5.嵌套循环：

外层循环控制总循环次数
内层循环控制每次具体实现的内容，

五. 方法 ：具有特殊工能的代码块

	提高代码复用
	1.方法的三要素：【修饰符】 返回值类型 函数名（形参列表）
		修饰符：public static 
	    函数的声明：可以不要函数体；例如：public static void iSRun（int a）；
	
	2.注意：1.与函数是平行关系，方法里面不能在定义方法
		  2.返回值return问题
			如果函数体返回值类型部位void，则函数体必须包含返回语句return；
			如果返回值类型为void，则return可有可无；

1.方法重载：

1.1在同一个类中，如果两个方法的名字相同，参数列表不同，则构 成重载
		参数个数不同 
		参数类型不同 
		与返回值类型无关
1.2 方法重载的好处 
	之前要实现类似功能，必须定义一大堆方法名，使用起来很繁琐 
	现在一个名字就可以，调用时传入不同实参自动区分

2.方法重载的底层实现：

3.1 java hello指令在内存的执行过程
	 1.在path路径下面找到java.exe
	 2.启动java虚拟机将hello.class装入内存，找main方法开始解析和执行
	
  3.2补充：
	函数不仅仅可以重载，还可以包含默认 缺省参数值；
	即参数值可以确定；确定之后调用时也可以传参；

补充：jar相关的命令：

javac -d bin  hello.java world.java ;将后面两个文件生成的class文件，放到bin目录下面
jar -cvf hello.jar -C bin .  ：把bin目录下面的class文件打包到hello.jar里面，后面带“.”是只打包该目录下的，不包括bin本身
jar -cvf hello.jar -C bin   ：把bin目录下面的class文件打包到hello.jar里面，后面不带“.”是打包该目录下的，包括该目录本身
java -cp hello.jar com.briup.test.hello :在当前的hello.jar包下面找com.briup.test里面的hello文件并执行；
 测试启动类加载器的时候可以把自己打包的jar文件放到/opt/jdk1.8.0_74/jre/lib/ext/下面
		sudo cp 自己的jar文件名.jar /opt/jdk1.8.0_74/jre/lib/ext/