Java学习之路-《周记》--菜鸟小回

---

title: Java学习之路-《周记》

• 工具(jdk+eclipse)

---

一、整体知识点

Java语言特性：

• 简单
• 面向对象—设计思想
• 可移植------一次编译，处处执行
• 健壮性------类型转换
• 分布式------可以分割为若干独立执行的程序
• 多线程
• 安全 ------类加载机制
• 高性能

1.数据类型

• java中变量使用（基本&引用数据类型）

  1. 基本数据类型

     • 类型： byte short int long float double boolean char
     • 字节数：1 2 4 8 4 8
     • 位数：字节数*8
     • 范围：-2^{（位数-1）}~2^{（位数-1）}
     • 声明：数据类型 变量名 [=值];
     • 注意事项：
       • java中所有的变量在使用之前必须完成赋值
       • 整数默认为是int类型；小数默认是double类型
       • long型末尾加L或者l；float型末尾加F或者f

  2. 数据类型的转换：

     • byte --> short --> int --> long --> float --> double
     • char向int以及之后的高等级数据类型遵循自动转换的原则
     • char和byte、short需要相互强制转换
     • 小数转换为整数的时候，丢失精度，只保留整数部分
     • 整数转换为小数的时候，自动提升精度等级
     • 自动转换(隐式转换)：转换自然发生
     • 强制转换:把赋值符右边变量的类型和左边的变量类型变得一致 byte=（byte）20;

  3. 运算符：

     • 算术: + - * / % ++ –
     • 比较: > < >= <= == !=
     • 赋值: = += -= /= *=
     • 逻辑: & | ^ ! && ||
     • 三元: 值的数据类型 变量名=条件表达式？值1：值2
     • 注意：
       • n++ 先赋值再++；++n 先++再赋值
       • +使用在字符串中是连接符
       • 比较较运算符的结果是boolean类型
       • &&：遇见false结束判断 ||：遇见true结束判断
       • &等级高于|
         

---

2.流程控制语句

• 顺序：从上往下，从左往右依次执行

• 选择：

  • if选择结构 if(条件){执行语句}
  • if-else 双分支选择结构 if(条件) {执行语句} else 执行语句
  • if-else if 多分支选择结构 if(条件){执行语句}else if(条件){执行语句} 适用于连续分布的区间
  • switch-case 闭合式选择结构 case 中 没有break，程序将会继续执行，直到找到下一个break;

    switch(表达式)
    {  
        case 值1:代码块1
             break;
        case 值2:代码块2
             break;
             ...
        default
            代码块;
    }
    

• 循环:循环执行
  • while while(条件){执行语句}
  • do-while do{执行语句}while(条件语句)
  • for for(初始化语句<1>;条件语句<2>;)
  • 多重循环

---

3.数组

• 定义：用来存储具有相同性质的数据的集合。存储的是批量数据。
• 数组是引用数据类型
• 数组中下标从0开始，最大下标=长度-1
• 数组一旦创建成功，长度不可更改
• length属性是数组的固有属性，用来获取数组的长度。使用形式:数组名.length
• 声明语法:

            数据类型[]  数组名;
    		数据类型 数组名[];

• 数组的赋值：

1.  int[] arr;
    arr = new int[10];
    
2.  String[] names={"如花","呵呵"};

3.  String[] names2=new String[]{"小明","小红","小黑"};

---

4.二维数组

• 语法格式:数据类型[][] 数组名 [= new 数据类型[二维数组的长度][]];
• 为二维数组的赋值：

1.  int[][] arr2=new int[3][]; //二维数组长度为3<1>
    arr2[0]=new int[]{1,2,3,4};
    arr2[1]=new int[3];
	arr2[2]=new int[5];
	
2.  int[][] arr3={{1,2,3},{2,5,8},{4,6,7,10}};

3.  int[][] arr4=new int[][]{{5,4,6},{5,4,1,4,7}};

• 注：

        int[][] arr2=new int[3][];
        arr2[0]={1,2,3,4}
		//直接初始化加赋值报错，因为上面利用new 创建

• foreach遍历(加强for循环)
  • 适用于对数组操作不需要下标值时
  • 语法：

  for(数据类型 变量名 : 数组) //变量名类型和数组中元素值类型相同
  {System.out.println(变量名);}
  

---

5.面向对象

• 在类的使用中，方法和属性的使用者是对象。对象在调用方法和属性之前一定要先实例化。
• 构造方法: 用来创建对象使用，是比较特殊的方法

  语法结构: [修饰符]   类类型([参数列表]){
  			构造方法体;
  		}
  

  注：
  1.构造方法没有返回值类型，连void都不能使用。
  2.构造方法的名字必须和类的名字保持一致。
  3.如果一个类没有显式的定义构造方法，那么系统会默认提供一个无参构造方法。如果显示的定义了构造方法，系统不再提供构造方法。
  4.类型定义了有参构造方法，一般都会把无参构造方法带上。
• 方法的重载： 在一个类中，方法名相同，参数列表不同的方法就叫做方法的重载
  参数列表不同:
  1、个数不同
  2、类型不同
  3、顺序不同
• 成员变量(全局变量)和局部变量的区别 :
  成员变量:直接在类中定义的属性也叫成员变量
  局部变量:定义在方法中的变量变量是局部变量
  1、成员变量有缺省值，局部变量没有缺省值。局部变量在使用之前一定要赋值
  2、成员变量所有方法都可以直接使用，局部变量只能在定义了这个变量的代码块中使用
  3、成员变量可以使用访问修饰符修饰，局部变量不能访问修饰符
• this关键字
  this：是当前类的一个实例(对象)
  1、当局部变量和成员变量重名时，成员变量被隐藏，使用[this.变量名]来访问被隐藏的成员 变量
  2、在本类的构造方法中，使用[this([参数列表])]来调用本类的其他构造方法
• 修饰符范围：
  public 公共的、公开的 所有类都可以访问
  protected 受保护的 本包以及非本包的子类中
  缺省 本包中
  private 私有的 只能在本类中直接使用
  

---

二、经典代码

1.循环算法

1、九九乘法表

package com.zhiyou.loop;

public class WorkMultiplication {

	public static void main(String[] args) {
		
		/*
		 * 99乘法表
		 * i代表行，j代表列  最多9行
		 * 列数与行数相等
		 */
		for(int i=1;i<=9;i++)    
		{
			for(int j=1;j<=i;j++)				//每列需要从1式递增到当前行数
			{
				System.out.print(j+"*"+i+"="+i*j+"\t");		//打印输出每行的式子
				if(i==j){System.out.println();}		//每当行数列数相等，换行！
			}
			//System.out.println();	等效上方
		}
	}

}

2.输入一个大于6的偶数，判断该数能被分解为两个质数之和。
a = b+c; c = a-b;

package com.zhiyou.loop;
import java.util.Scanner;
public class WorkSumOfPrimes {

	public static void main(String[] args) {
		Scanner input =new Scanner(System.in);
		int num=input.nextInt();				//输入一个num
		
		if(num<=6||num%2!=0)
		{System.out.println("输入不合法，请重新输入");}
		else
		{										//输入的num是6以上的偶数
			out: for(int i=2;i<=num/2;i++)
			{
				for(int j=2;j<=i/2;j++)  		//如果i不是质数，跳出该循环，寻找下一个
				{
					if(i%j==0){
						continue out;
					}
				}

				int primeA=i,primesB;			//执行到此还未跳出，说明i是质数赋值给primeA
				primesB=num-primeA;				//令primesB=num-primeA
				boolean primesBTestB=true;		//声明boolean类型变量来记录b是否为质数
				
				//接下来需要判断b是否为质数
				for(int c=2;c< primesB ;c++)
				{                                           

					if(primesB%c==0)
					{
						primesBTestB=false;
						break;
					}
				}
				if(primesBTestB&&(primeA!=primesB)){
					System.out.println(primeA+"+"+primesB+"="+num);
				}
	
			}
		System.out.println("以上程序验证到大于6的偶数的确可以表示成一个、甚至多个质数的和！");
	
		}

	}

}

3.分开输入年、月、日，判断是一年的第几天？
闰年:非整百年被4整除，整百年被400整除

package com.zhiyou.loop;
import java.util.Scanner;
public class WorkYearMonthDay {

	public static void main(String[] args) {
		
		/*
		 * 
		 * 分开输入年、月、日，判断是一年的第几天？
		 * 
		 * 闰年:非整百年被4整除，整百年被400整除
		 * 
		 * 分析： 当前天数= 31天月份的个数*31 + 30天月份的个数*30 + 二月份天数
		 * 需要判断求出这三种类型月份的个数 a，b
		 * 
		 */
		
		
		Scanner input =new Scanner(System.in);
		//请输入年月日
		System.out.println("输入一个年份");
		int year=input.nextInt();
		System.out.println("输入一个月份");
		int month=input.nextInt();
		System.out.println("输入一个日");
		int day=input.nextInt();
		
		boolean rn=false;			//判断闰年
		
		if((year%4==0&year%100!=0)|year%400==0){
			rn=true;				//符合条件为闰年
		}
		//排除用户错误输入，此处忽略年份过大的问题
		if( year<=0 || month<1 || month>12 || (rn==false)&&(month==2)&&(day>28))
		{System.out.println("输入格式错误，请重新输入！");}
		else{
		
		int sum=0;
		int a=0,b=0;		//a为31天月份个数，b为30天月份个数
		
		if(month>2){											//判断是否超过二月
			/*if(rn==true)			
			{
				day=day+29;										//闰年超过二月，加上29天
			}else
				day=day+28;	*/									//平年超过二月，加上28天
		}
			day=rn?(day+29):(day+28);							//等效三元运算符
	
		
		for(int i=1;i<month;i++)
		{
			
			if((i==1)|(i==3)|(i==5)|(i==7)|(i==8)|(i==10)|(i==12))		
			{
				a++;											//31天月份的个数
			}
			if((i==4)|(i==6)|(i==9)|(i==11))
			{
				b++;											//30天月份的个数
			}
		}
		
		sum=a*31+b*30+day;					// 当前天数= 31天月份的个数*31 + 30天月份的个数*30 + 二月份天数
		System.out.println("输入的日期是今年的"+sum+"天");
		}
	}

}

---

2.排序算法

1.冒泡排序

package com.zhiyou.arraysort;

public class BubbleSort {

	public static void main(String[] args) {
		/*
		 * 冒泡排序：
		 * 降序
		 * 升序
		 * 
		 */
		int[] arr={100,1,25,187,68,35};
		
		for(int i=0;i<arr.length-1;i++){     						 //i表示需要比较的轮数 arr.length-1次
			for(int j=0;j<arr.length-1-i;j++){					 	 //j表示每轮要比较的次数
				if(arr[j]>arr[j+1]){									//第一轮 i=0;j=5
					int c=arr[j];										//第二轮 i=1;j=4
					arr[j]=arr[j+1];									//第三轮 i=2;j=3
					arr[j+1]=c;											//....
				}														//可得i+j=length-1                                                            
			}
		}
		for(int i:arr){
			System.out.print(i+" ");
		}

	}

}

2.插入排序：

package com.zhiyou.arraysort;

public class InsertSort {

	public static void main(String[] args) {
		
		/*
		 * 插入排序
		 */
		int[] arr={100,1,25,187,68,35};
		for(int i=0;i<arr.length-1;i++)	//i表示当前轮数
		{
			//第一轮 i=0;j=1 只需要下标1数与下标0数相比
			//第二轮 i=1;j=2 需要下标2数与下标1数相比，选出较小的前移，再让下标1与下标0相比，较小的前移
			//.....
			for(int j=i+1;j>0;j--)		
			{
				if(arr[j]<arr[j-1])			//想要升序
				{
					int c=arr[j];
					arr[j]=arr[j-1];
					arr[j-1]=c;
				}else
					break;			//如果第一次比较时就大于下标为i的数，直接跳出循环无需比较
			}
		}
		for (int i : arr) {
			System.out.print(i+"   ");
		}
		

	}

}

3.选择排序：

package com.zhiyou.arraysort;

public class SelectSort {

	public static void main(String[] args) {
		/*
		 * 选择排序
		 * 先拿第一个数，作为最小值，第一个数与后面所有数对比，找到比他小的，将最小值下标替换为他。
		 * 整个数组遍历完成，讲最小的值跟第一个数交换
		 */
		int[] arr={100,1,25,187,68,35};
		for(int i=0;i<arr.length-1;i++)		//i为当前的数值
		{
			int min=i;
			for(int j=i+1;j<arr.length;j++)
			{
				if(arr[min]>arr[j])
					min=j;
			}
			if(min!=i){
				int c=arr[i];
				arr[i]=arr[min];
				arr[min]=c;
			}
		}
		for (int i : arr) {
			System.out.print(i+"   ");
		}
	}
}

---

3.数组遍历算法

1.去除数组中的0项(利用遍历直接标记作为新数组下标)：

package com.zhiyou.day03work;

public class WorkArrayDislodge {
	public static void main(String[] args) {
		int[] arr = {0,0,1,3,5,1,2,0,2,0,0};
		int flag=0;
		for(int i:arr)
		{
			if(i==0){
				flag++;
			}
		}
		int[] arr1=new int[arr.length-flag];
		int index=0;
		for(int i:arr)
		{
			if(i!=0){
			arr1[index]=i;
			index++;
			}
		}
		for(int i:arr1){
			System.out.print(i+" ");
		}
	}
}