Java编程基础

Java中的变量

 变量的数据类型

注:String 类型不是基本数据类型，它实际上是final修饰，所以也不可以继承。

• • float

　　　　float 是单精度类型，当你不声明的时候，默认小数都用 double 来表示，如果要用 float 的话，则应该在其后加上 f 。

　　例如：float a = 1.3;

　　　　则会提示不能将 double 转化成 float 这成为窄型转化

　　正确：float a = 1.3f;

数据类型转换

• • boolean类型不参与转换
  • 默认转换

　　从小到大：byte , short , char — int — long — float — double

　　byte , short , char 之间不相互转换，直接转成 int 类型参与运算。

• • 思考题

1、下面程序是否有问题
    	byte b1 = 3;
		byte b2 = 4;
		byte b3 = b1 + b2;
		byte b4 = 3 + 4;
	答：
		b1、b2 是变量在做运算时默认转化成 int 类型，int类型赋值给 byte 类型会编译报错。
		3、4 是常量相加为 7 ，检查是否在数据类型范围内，如果不在编译报错，如果在赋值给 byte 类型不会报错。

2、byte b = 300; 是否有问题，如果有如何修改？结果是什么？
	答：
		300的二进制表示：00000000 00000000 00000000 100000010
		转化成 byte 后为 100000010,第一位为符号位会损失精度，所以会报错应该是 byte b = (byte)300; 
		100000010这个是截取后的补码:源码为:
		                符号位			数值位
			补码:		  1             0000010
			反码:		  1				0000001
			源码:		  1				1111110
			
3、字符串参与运算 是查找ASCII里的值
		‘a'	97
		'A' 65
		'0'	68
		System.out.println('a');	//a
		System.out.println('a' + 1);	//98

4、字符串参与运算 是字符串的链接
		System.out.println("hello" + 'a' + 1);	//helloa1
		System.out.println('a' + 1 + "hello");	//98hello
		System.out.println("5+5=" + 5 + 5);	//5+5=10
		System.out.println(5 + 5 + "=5+5");	//10=5+5

变量的作用域

变量定义在哪个大括号内，它就在这个大括号内有效。　

　

Java中数据传递

基本数据类型

/*
    1、Java中的参数传递
          当 传递基本数据类型的时候，形参的改变 对 实参 是没有影响的
          当 传递引用数据类型的时候，形参的改变 对 实参 是有影响的 
*/

引用数据类型

Java中运算符

算术运算符

• • ++和--参与操作使用

　　放在操作数的前面：先自增或者自减，再参与操作

　　int a = 10;
　　int b = ++a;
　　放在操作数的后面：先参与操作，再自增或者自减

　　int a = 10;
　　int b = a++;

• • 赋值运算符

　　扩展的赋值运算符的特点：隐含了自动强制转换。

　　面试题：
　　short s = 1;
　　s = s + 1;

　　short s = 1;
　　s += 1;
　　请问上面的代码哪个有问题?

• • 逻辑运算符

　　位运算符(了解)
　　　　A:^的特殊用法
　　　　　　一个数据针对另一个数据位异或两次，该数不变
　　　　B:面试题
　　　　　　a:请实现两个变量的交换
　　　　　　　　**采用第三方变量
　　　　　　　　**用位异或运算符
　　　　　　　　　　左边a,b,a
　　　　　　　　　　右边a^b
　　　　　　b:请用最有效率的方式计算出2乘以8的结果
　　　　　　　　2<<3

键盘录入（掌握）

　　　　(1)实际开发中，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。
　　　　(2)如何实现呢?目前就记住
　　　　　　A:导包
　　　　　　　　　import java.util.Scanner;
　　　　　　　　　位置：在class的上边
　　　　　　B:创建对象
　　　　　　　　　Scanner sc = new Scanner(System.in);
　　　　　　C:获取数据
　　　　　　　　　int x = sc.nextInt();
　　　　(3)把三元运算符的案例加入键盘录入改进。

选择结构语句

switch条件语句

1、格式：
    	switch(表达式) {
			case 值1:
				语句体1;
				break;
			case 值2:
				语句体2;
				break;
			...
			default:
				语句体n+1;
				break;
		}
		
		格式解释说明：
			表达式:可以是byte,short,int,char
				JDK5以后可以是枚举
				JDK7以后可以是字符串
			break:表示程序到这里中断，跳出switch语句
			default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else
2、面试题
		switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?
			可以,不可以,JDK7以后可以
3、注意事项:
		A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
		B:default可以省略吗?
			可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
			特殊情况：
				case就可以把值固定。
				A,B,C,D
		C:break可以省略吗?
			可以省略，但是结果可能不是我们想要的。
			会出现一个现象：case穿透。
			最终我们建议不要省略
		D:default一定要在最后吗?
			不是，可以在任意位置。但是建议在最后。
		E:switch语句的结束条件
			a:遇到break就结束了
			b:执行到末尾就结束了
4、案例：
		A:键盘录入一个数字(1-7),输出对应的星期几。
		B:单项选择题
		C:键盘录入一个字符串的问题
			String s = sc.nextLine();
		D:根据给定的月份,输出对应的季节
5、if语句和switch语句各自的场景
		A:if
			针对boolean类型的判断
			针对一个范围的判断
			针对几个常量的判断
		B:switch
			针对几个常量的判断

循环结构语句

for和while的区别

			1、使用上的区别
				for语句的那个控制条件变量,在循环结束后不能在使用了。
				而while的可以继续使用。
			2、理解上的区别
				for适合于一个范围的判断
				while适合次数不明确的
					举例:吃葡萄
			3、案例		
				把for语句的练习用while改进:
				a:在控制台打印水仙花数
				b:统计水仙花个数
					/*
						水仙花数:一个三位数，其各位数字的立方和等于该数本身。
					*/
						//三位数其实是告诉了我们范围。
						for(int x=100; x<1000; x++) {
							int ge = x%10;
							int shi = x/10%10;
							int bai = x/10/10%10;
			
						//让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
							if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
								//如果相同，就把该数据在控制台输出。
								System.out.println(x);
				c:改进版的回文数
					/*
						一个五位数
						个位 = 万位
						十位 = 千位
						个位 + 十位 + 千位 + 万位 = 百位
					*/
						public static void main(String[] args) {
							//五位数就告诉了我们范围。
							for(int x=10000; x<100000; x++) {
								//分解每一个五位数的个，十，百，千，万位上的数据
								int ge = x%10;
								int shi = x/10%10;
								int bai  = x/10/10%10;
								int qian = x/10/10/10%10;
								int wan = x/10/10/10/10%10;
								
								//按照要求进行判断即可
								if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) {
									System.out.println(x);
								}
							}
						}
				
				d:输出九九乘法表
					public static void main(String[] args) {
						for(int x=0; x<9; x++) {
							for(int x=1; x<=9; x++) {
								for(int y=1; y<=x; y++) {
									System.out.print(y+"*"+x+"="+y*x+"	");
								}
								System.out.println();
							}
					}
					
				a:珠穆朗玛峰问题
					/*
						我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
						请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
					*/
						public static void main(String[] args) {

							int count = 0;
							int end = 884800;
							int start = 1;
							
							while(start<end) {
								count++;
								start *= 2;
		
								System.out.println("第"+count+"次厚度是"+start);
							}
							System.out.println("要叠"+count+"次");
						}
						
				b:小芳存钱问题(break以后才能做)
				/*
					需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，
						  每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
						  请问，经过多少天，小芳才可以存到100元钱。
				*/
					public static void main(String[] args) {
						//每天要存储的钱是2.5元
						double dayMoney = 2.5;
						
						//存钱的初始化值是0
						double daySum = 0;
						
						//从第一天开始存储
						int dayCount = 1;
						
						//最终存储不小于100就不存储了
						int result = 100;
						
						//因为不知道是多少天，所以我用死循环，
						while(true) {
							//累加钱
							daySum += dayMoney;
							
							//一旦超过100元我就退出循环。
							if(daySum >= result) {
								System.out.println("共花了"+dayCount+"天存储了100元");
								break;
							}
							
							if(dayCount%5 == 0) {
								//花去6元钱
								daySum -= 6;
								System.out.println("第"+dayCount+"天花了6元钱");
							}
							
							//天数变化
							dayCount++;
						}
					}

do...while和for、while的区别

			1、do...while循环至少执行一次循环体

控制跳转语句

			1、do...while循环至少执行一次循环体
			2、填空题
			for(int x=1; x<=10; x++) {
				if(x%3 == 0) {
					//补齐代码
				}
				System.out.println("Java基础班");
			}
			如何让控制台输出2次：Java基础班
			如何让控制台输出7次：Java基础班
			如何让控制台输出13次：Java基础班

方法

方法的注意事项

如果方法有明确的返回值类型，就必须有return语句返回。

数组

定义格式

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

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

　　推荐是用A方式，B方法就忘了吧。 但是要能看懂

数组的初始化

　　A:动态初始化 只给长度，系统给出默认值 举例：

　　　　int[] arr = new int[3];

　　B:静态初始化 给出值，系统决定长度 举例：

　　　　int[] arr = new int[]{1,2,3};

　　　　简化版：int[] arr = {1,2,3};

数组长度

　　int len = arr.length;

Java的内存分配

　　A:栈 存储局部变量

　　B:堆 存储所有new出来的

　　C:方法区(面向对象部分详细讲解)

　　D:本地方法区(系统相关)

　　E:寄存器(CPU使用)

　　注意：

　　　　a:局部变量 在方法定义中或者方法声明上定义的变量。

　　　　b:栈内存和堆内存的区别

　　　　　　栈：数据使用完毕，就消失。

　　　　　　堆：每一个new出来的东西都有地址 每一个变量都有默认值

　　　　　　　　byte,short,int,long 0

　　　　　　　　float,double 0.0

　　　　　　　　char 'u0000'

　　　　　　　　boolean false

　　　　　　　　引用类型 null 数据使用完毕后，在垃圾回收器空闲的时候回收。

数组内存图

 二维数组（理解）

　　元素是一维数组的数组

• • 格式

　　　A:数据类型[][] 数组名 = new 数据类型[m][n];
　　　B:数据类型[][] 数组名 = new 数据类型[m][];
　　　C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
　　　D:数据类型[][] 数组名 = {{...},{...},{...}};

• • m,n

　　　数组名.length;

　　　数组名[].length;

• • 案例(掌握)

　　　A:二维数组的遍历

　　　public static void printArray2(int[][] arr) {

　　　　　　for(int x=0; x<arr.length; x++) {
　　　　　　　　for(int y=0; y<arr[x].length; y++) {
　　　　　　　　　　System.out.print(arr[x][y]+" ");
　　　　　　　　}
　　　　　　　　System.out.println();
　　　　　　}
　　　　}

　　　B:杨辉三角形　　

/*

    需求：打印杨辉三角形(行数可以键盘录入)
    
    1
    1 1    
    1 2 1
    1 3 3 1
    1 4 6 4 1 
    1 5 10 10 5 1

    分析：看这种图像的规律
        A:任何一行的第一列和最后一列都是1
        B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
    
    步骤：
        A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
          这个n的数据来自于键盘录入。
        B:给这个二维数组任何一行的第一列和最后一列赋值为1
        C:按照规律给其他元素赋值
            从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
        D:遍历这个二维数组。
*/
import java.util.Scanner;

class Array2Test3 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        //这个n的数据来自于键盘录入。
        System.out.println("请输入一个数据：");
        int n = sc.nextInt();
        
        //定义二维数组
        int[][] arr = new int[n][n];
        
        //给这个二维数组任何一行的第一列和最后一列赋值为1
        for(int x=0; x<arr.length; x++) {
            arr[x][0] = 1; //任何一行第1列
            arr[x][x] = 1; //任何一行的最后1列
        }
        
        //按照规律给其他元素赋值
        //从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
        for(int x=2; x<arr.length; x++) {
            //这里如果y<=x是有个小问题的，就是最后一列的问题
            //所以这里要减去1
            //并且y也应该从1开始，因为第一列也是有值了
            for(int y=1; y<=x-1; y++) {
                //每一个数据是它上一行的前一列和它上一行的本列之和。
                arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
            }
        }
        
        //遍历这个二维数组。
        /*
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<arr[x].length; y++) {
                System.out.print(arr[x][y]+"	");
            }
            System.out.println();
        }
        */
        //这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print(arr[x][y]+"	");
            }
            System.out.println();
        }
    }
}

　　　　

　　　　C:数据转成数组

    int index = 0;
        
        while(number > 0) { //number=123456,number=12345,number=1234,number=123,number=12,number=1,number=0
            arr[index] = number%10; //arr[0]=6,arr[1]=5,arr[2]=4,arr[3]=3,arr[4]=2,arr[5]=1
            index++;//index=1,index=2,index=3,index=4,index=5,index=6
            number/=10;//number=12345,number=1234,number=123,number=12,number=1,number=0
        }