12.25笔记与作业

1、数据类型：

　　数值型：整型{整型（int）、短整型（short）、字节型（byte）、(长整型 )long}

　　　　　　浮点型：double、float

　　非数值型：字符型（char）、布尔类型（boolean）、字符串类型（String）、其它引用类型

 

　　面试题1：1、请问JAVA中8大基本类型？

　　　　　　答：数值型：整型（int）、短整型（short）、字节型（byte）、(长整型 )long

　　　　　　　　浮点型：double、float

　　　　　　　　非数值型：字符型（char）、布尔类型（boolean）

 

2、数据类型转换：

public class GuanXi {
	public static void main(String[] args) {
		int a = 1;
		double b = a;
		System.out.println(b);
	}
}

　　结果为：1.0；

 

　　此为自动类型转换，原则：1、类型可以兼容；2、目标类型大于源类型；

public class GuanXi {
	public static void main(String[] args) {
		double a = 12.5;
		int b = (int)a;
		System.out.println(b);
	}
}

　　结果为：2；

　　此为强制类型转换，原则：1、类型可以兼容；2、目标类弄小于源类型；

 

3、运算符

　　a、赋值运算符： =

　　b、算术运算符：+、-、*、/、%、++、--、+=、-=、*=、/=

　　c、关系运算符：==、！=、>、<、>=、<=

　　d、逻辑运算符：&、|、^、！、&&、||

　　e、位运算符：&、|、^、~、<<、>>、>>>

　　f、条件运算符（也号三目运算符或三元运算符）

　　　　表达式为：

　　　　　　条件？表达式1：表达式2    即条件为TRUE运行表达式1，FALSE运行表达式2

　　

 4、关系运算符：==、！=、>、<、>=、<=

　　A、=为赋值运算符，==为等于运算符

　　B、关系表达式的结果为布尔值

　　C、>、<、>=、<=运算符的优先级别高于==、！=

　　D、>、<、>=、<=运算符只支持数值类弄的数据比较

 

　　PS：基本数据类型在做关系运算时，直接将变量值进行比较运算；引用型数据类型，在做关系运算时，比较的是地址（如String）；

　　1）、数值型之间的比较运算

package com.java12_25;
//数值型之间的比较运算
public class GuanXi {
	public static void main(String[] args) {
		int a = 12; //声时变量并赋值
		double b = 11.6; //声时变量并赋值
		
		System.out.println(12>11.6);//直接数值比较，输出结果
		//使用变量进行比较，输出结果
		System.out.println(a>b);
		System.out.println(a>=b);
		
		System.out.println(a==b);
		System.out.println(a!=b);
		
		System.out.println(a<b);
		System.out.println(a<=b);
	}
}

　　结果为布尔类型，TRUE或FALSE

　　面试题2：==与equals的区别

　　　　答：A、==通常作数值的相等关系比较；equals通常作引用型数据类型的相等比较

　　　　　　B、==比较的是变量的地址是否是同一个地址；equals比较的是变量指向的值是否相同

 　　如下例：

package com.java12_25;
//字符之前使用==和equals比较
public class GuanXi1 {
	public static void main(String[] args) {
		
		String c = "3"; 
		String d = "3";
		
		System.out.println("相同"=="相同");//字符串直接比较，值相同，结果为TRUE
		System.out.println(3==3);//直接进行数值比较与下面变量之间比较做对比
		System.out.println(c==d);//因为二者地址相同，所以结果为TRUE
		System.out.println(c.equals(d));//因equals比较的是二者的数值，所以结果为TRUE		
		
		String a = new String("2");
		String b = new String("2"); //声明时更换地址
		
		System.out.println(2==2);//直接进行数值比较与下面变量之间比较做对比
		System.out.println(a==b);//因为因为二者地址不相同，尽管数值一样，但结果为FALSE
		System.out.println(a.equals(b));//因equals比较的是二者的数值，与地址无关，所以结果为TRUE
	}
}

　　结果为：

 

5、逻辑运算符：

　　&&：短路且，两个操作数都为TRUE，整个结果为TRUE

　　||：短路或，两个操作数有一个为TRUE，整个结果为TRUE

　　&：逻辑且，两个操作数都为TRUE，整个结果为TRUE；不论左边取值，右边都会进行运算，并且可用于位运算

　　|：逻辑或，两个操作数有一个为TRUE，整个结果为TRUE；不论左边取值，右边都会进行运算，并且可用于位运算

　　^：逻辑异或，两个操作数相同，结果为FALSE；两个操作数不同，结果为TURE

　　!：逻辑反（逻辑非），操作数为TRUE，结果为FALSE；操作数为FALSE，结果为TRUE

 　　示例：

　　　　1）、&&短路且：左边表达若为FALSE，则右边不作运算；||短路或：只要有一个操作数为TRUE，结果TRUE，若左边为TRUE，右边不作运算

public class LuoJi {
	public static void main(String[] args) {
		int a = 11;
		int b = 12;
		System.out.println((++a==b)&&(++a!=b));//表达式左边为TRUE，因此继续运行右边，右边运算结果也为TRUE，结果输出为TRUE
		System.out.println(a);//左右两边都有进行运算，a值为13
		
		System.out.println("---------");
		int c = 13;
		int d = 14;
		System.out.println((++c!=d)&&(++c==d));//表达式左边运算结果为FALSE，右边不作运算，直接输出结果为FALSE
		System.out.println(c);//右边不作运算，因些c值为14
		
		System.out.println("---------");
		int e = 15;
		int f = 16;
		System.out.println((++e==f)||(++e!=f));//表达式左边为TRUE，右边不作运算，只要左右两边有一个为TRUE，结果为TRUE
		System.out.println(e);//右边不作运算，因些c值为16
	}
}

　　　　结果为：

　　　　2）、逻辑&和逻辑|

public class LuoJi1 {
	public static void main(String[] args) {
		int a = 11;
		int b = 12;
		System.out.println((++a==b)&(++a!=b));//表达式左、右边运算结果为TRUE，结果输出为TRUE
		System.out.println(a);//左右两边都会进行运算，a值为13
		
		System.out.println("---------");
		int c = 13;
		int d = 14;
		System.out.println((++c!=d)&(++c==d));
		//表达式左边运算结果为FALSE，右边继续作运算但不管运算结果为TRUE或FALSE，表达式结果都为FALSE
		System.out.println(c);//左右两边都会进行运算，因些c值为15
		
		System.out.println("---------");
		int e = 15;
		int f = 16;
		System.out.println((++e==f)|(++e!=f));
		//表达式左边为TRUE，右边继续运算，不管运算结果为TRUE或FALSE，只要左右两边有一个为TRUE，结果为TRUE
		System.out.println(e);//左右两边都会进行运算，因些c值为17
	}
}

　　　　结果为：

　　　　3）、逻辑异或：两个操作数结果相同，结果为FALSE；两个操作数结果不相同，结果为TRUE

public class LuoJi2 {
	public static void main(String[] args) {
		int a = 11;
		int b = 12;
		System.out.println(!(++a==b));//操作数运算结果为TRUE，非运算后最后结果为FALSE
		System.out.println(a);//a自加，结果为12
		
		System.out.println("-----------");
		
		int c = 13;
		int d = 14;
		System.out.println((a==b)^(++c==d));//左右两个操作数运算结果相同，逻辑异或运算后结果为FALSE
		System.out.println(c);//c自加，结果为14
		System.out.println((a==b)^(c!=d));//左右两个操作数运算结果不相同，逻辑异或运算后结果为TRUE
	}
}

　　　　结果为：

 

6、位运算符

　　1）、&：按位与：两个操作数都为1，结果为1

　　2）、|：按位或：两个操作数有一个为1，结果为1

　　面试题4：6&7=？ 6|7=？

　　　　两个数值的转成二进制数值进行每位的&或者|运算

　　　　　　6&7=6　　 6|7=7

　　　　　　  110 　　  110

　　　　　　&111　　 | 111

　　　　　　  110 　　  111

public class WeiSuan {
	public static void main(String[] args) {
		System.out.println(6&7);
		System.out.println(6|7);
		//换成二进制进行运算，结果再换成十进制输出
	}
}

　　结果为：

　　3）、^：按位异或：两个操作数相同，结果为0，不相同结果为1

　　　　　　11^12=7　　

　　　　　　  1011　　  

　　　　　　^1100　　

　　　　　　  0111 　　  

public class WeiSuan1 {
	public static void main(String[] args) {
		System.out.println(11^12);
		//换成二进制进行运算，结果转成十制输出
	}
}

　　　　结果为：

　　4）、~：按位非/取反：操作数为1，结果为0，操作数为0，结果为1　????

　　5）、<<：左移：右侧空位补0

　　6）、>>：右移：左侧空位补最高位，即符号位

　　7）、>>>：无符号右移：左侧空位补0

　　　　示例：

　　　　面试题3：如何以最快的方式求出2的3次方？

　　　　　　System.out.println(2<<2);使用位运算符，将2往前移两位；

public class WeiSuan3 {
	public static void main(String[] args) {
		//求2的3次方
		System.out.println(2*2*2);//正常下操作，相乘输出即可
		
		System.out.println("--------");
		System.out.println(2<<2);//换算成二进制00000010，后向右移动2位，左侧补0，结果为00001000，输出十进制为8
		
		System.out.println("--------");
		System.out.println(50>>3);//换算成二进制00110010，后向右移动三位，左侧补0，结果为110，输出十进制为6
		
		System.out.println(50>>>3);//换算成二进制00110010，后向右移动三位，左侧补0，结果为110，输出十进制为6
		
	}
}

　　　　结果为:

　　　　面试题5：&和&&的区别

　　　　　　答：1、&表是逻辑且，无论第一个操作数是否为TRUE，第二个操作数都执行

　　　　　　　　&&表示短路且，第一个操作数为FALSE时后面的操作数不执行，返回FALSE

　　　　　　　　2、&还可以用作位运算，&&只能做逻辑运算

 

7、条件表达式：也三目表达式或三元表达式

　　　　条件？表达式1：表达式2

　　　　　　条件为TRUE，运行表达式1，反之运行表达式2

　　　　PS：如果要用一个变量接收表达式结果，表达式后面两个结果类型要一样

　　示例：

 

import java.util.Scanner;

public class TiaoJian {
	public static void main(String[] args) {
		Scanner cxj = new Scanner(System.in);
		System.out.println("请输入第一个数：");
		int a = cxj.nextInt();
		System.out.println("请输入第二个数：");
		int b = cxj.nextInt();;
		int c = a<b?a:b;//对键盘上输入的两个数值进行比较，若第一个数小于第二个数，则输出第一个数，反之输出第二个数
		System.out.println(c);
	}
}

 

　　　　运行示例结果：

 

作业：

　　1、银行提供了整存整取定期储蓄业务，其存期为一年、两年、三年、五年到期凭存单支取本息。

　　　　年利率为一年：2.25%；

　　　　　　　　两年：2.7%；

　　　　　　　　三年：3.24%；

　　　　　　　　五年：3.6%；

　　　　编写一个程序，输入存入的本金数目，计算假设存一年、两年、三年或五年到期取款时银行应支付的本息多少？（以课本结果为标准编写）

import java.util.*;
public class BenJin {
	public static void main(String[] args) {
		double benjin;
		System.out.println("请输入本金：");
		Scanner input = new Scanner(System.in);
		benjin = input.nextDouble();
		System.out.println("本金是："+benjin);
		
		//计算每年的利息加本金
		double benxi1 = benjin + benjin*0.0225;
		System.out.println("第一年的本息是："+benxi1);
		
		double benxi2 = benjin + benjin*0.027*2;
		System.out.println("第二年的本息是："+benxi2);
		
		double benxi3 = benjin + benjin*0.0324*3;
		System.out.println("第三年的本息是："+benxi3);
		
		double benxi5 = benjin + benjin*0.036*5;
		System.out.println("第五年的本息是："+benxi5);
		
	}
}

　　　　结果为：

 

预习：

流程控制--选择结构与循环结构

1、流程控制结构：顺序结构、选择结构和循环结构

　　1）、顺序结构：程序从上向下依次执行每条语句的结构；

　　2）、选择结构：根据条件判断的结果来选择执行不同的代码；

　　　　　　有if控制语句和switch语句

　　3）、循环结构：根据判断条件来重复性地执行某段代码；

　　　　　　有while语句、do-while语句、for语句

2、选择结构有if控制语句和switch语句

　　1）、if控制语句有3种不同的形式，分别为单分支结构、双分支结构和多分支结构

　　　　A、单分支结构：

　　　　if（表达式）{

　　　　　　语句；

　　　　}

　　　　a、if为关键字；

　　　　b、表达式为布尔类型的表达式，结果为true或false；

　　　　B、双分支结构：

　　　　if(表达式){

　　　　　　语句1；

　　　　}else{

　　　　　　语句2；

　　　　}

　　　　执行步骤：

　　　　　　对表达式进行判断，结果为true，则执行语句1；反之执行语句2；

　　　　PS：else子句不能单独使用，必须是IF语句的一部分，与最近的if语句配对使用；else后可再进行if语句，进行多分支选择

 

 

 

 

 

 

 

 

 

 

 

 

转载于:https://www.cnblogs.com/chenxj/p/10173194.html