Java入门笔记
变量:分配在内存上的一块存储位置
数据类型:
1-整形:byte,short,int,long;
细节:声明常量整形一般为int,如果要更改要在常量后加L
2-浮点数:float, double
浮点数 = 符号位 + 指数位 + 尾数位(面试)
尾数位容易丢失,造成精度损失(小数都是近似值)
public class Main{
public static void main(String[] args){
//浮点数使用陷阱:2.7和8.1 / 3 比较
//看看一段代码
double num1 = 2.7;
double num2 = 8.1 / 3;
System.out.println(num1);//2.7
System.out.println(num2);//2.69999997
if(num1 == num2){//错误写法,
System.out.println("equal");
}
// 应该是以两个数的差值的绝对值,在某个精度范围内判断
if(math.abs(num1 - num2) < 0.000001){//此为正确写法,
System.out.println("equal");
}
//细节:如果是直接查询得到的小数或直接赋值,可以判断相等
}
}
3-字符型char
package com.sxt;
public class demo {
public static void main(String[] args) {
char n1 = '刘';//用单引号
char n2 = 'a';
char n3 = 97;
char n4 = '\t';//转义字符被视为一个单字符
System.out.println(n1);//刘
System.out.println(n2);//a
System.out.println(n3);//a,输入的是对应的Unicode码
//字符运算
System.out.println('a' + 10);//107
//test
char n5 = 'b' + 1;//99
System.out.println((int)n5);//99
System.out.println(n5);//99对应的unicode
}
}
字符类型的本质(数字(二进制))
存储:‘a’ =>码值97=>二进制===>存储
读取:二进制===>97===>‘a’
字符编码表
1,ASCII,一个字节表示,可表示256个字符,常用128个
2,gbk,可表示汉字,字母一个字节,汉字2个字节
3,gb2312:gbk 的缩小版
4,utf-8(万国码)字母一个字节,汉字3个字节(可表示更多)
5, big5,繁体
4-布尔类型boolean
基本数据转换:
package com.sxt;
public class demo {
public static void main(String[] args) {
//细节1:从低精度想高进度,反之不可
double n1 = 80;
int n2 = '刘';
//float n3 = 12.99;wrong
//short n4 = 2.1;wrong
//细节2:存在多种类型转换时会,会自动转换成容量最大的那个数据类型
int n3 = 10;
// float n4 = n3 + 1.1; wrong,类型的最终是double
// float n5 = n3 + 1.1F;right
//细节3:;byte,short, char 这三者不会相互转换
//当把具体数值赋给byte时(1)先判断该值是否在byte的范围内
byte n7 = 10;//right
int n8 = 10;//n8是int
// byte n9 = n8;//wrong,变量赋值,判断类型
// char n10 = n7;//wrong
//细节4:(byte, short) 和char 三者可以计算,计算时首先转成int
byte b1 = 10;
byte b2 = 1;
char b3 = 'a';
// float b = b1 + b3;wrong
int a = b1 + b3;
//细节5:boolean不参与转换
//提升原则:有大选大
}
}
强制类型转换:
一般是由大转小
package com.sxt;
public class demo {
public static void main(String[] args) {
//细节1:强转只针对最近的操作数有效,可以使用小括号提升优先
int x = (int)(10 * 3.5 + 6 * 1.5);
System.out.println(x);
//细节2:char类型可以保存int常量,保存int的变量值时,要强转
char n = 100;
int m = 100;
char n2 = (char)m;
System.out.println(n2);
}
}
String 和基本数据类型的转换
String n = 123 + “”;
package com.sxt;
public class demo {
public static void main(String[] args) {
String str1 = "123";
int n2 = Integer.parseInt(str1);
double n3 = Double.parseDouble(str1);
float n4 = Float.parseFloat(str1);
short n5 = Short.parseShort(str1);
byte n6 = Byte.parseByte(str1);
boolean n7 = Boolean.parseBoolean("true");
char n8 = str1.charAt(0);
System.out.println(n2);
System.out.println(n3);
System.out.println(n4);
System.out.println(n5);
System.out.println(n6);
System.out.println(n7);
System.out.println(n8);
}
}
运算符
package com.sxt;
public class demo {
public static void main(String[] args) {
System.out.println(10 / 4); //2
System.out.println(10 / 4.0); //2.5
System.out.println(10 % 3); //1
System.out.println(-10 % 3); //-1
System.out.println(-10 % -3); //-1
System.out.println(10 % -3); //1
//a % b = a - a / b * b;
}
}
原码,反码,补码(重点)
1,二进制的最高位是符号位,0表示正数,1表示负数(口诀:0->0 1->-)
2,正数的原码,反码, 补码都一样
3,负数的反码 = 他的原码符号位不变,其他位取反
4,负数的补码 = 他的反码 +1,负数的反码 = 负数的补码 -1
5,0的反码,补码都是0
6,java没有无符号位,换言之,java中的数都是有符号的
7,在计算机运算时,都是以补码的方式来运算的
8,当我们看运算结果时,看他的原码
位运算符
&(按位与):两位全为1,结果为1,否则为0
|(按位或):两位中有一个为1,结果为1,否则为0
^(按位异或):两位中一个为0,一个为1,结果为1,否则为0
~(按位取反):0->1,1->0
package com.sxt;
import java.util.Scanner;
public class demo {
public static void main(String[] args) {
// ~ (按位取反)
//以为是正数,三码合一,注意:在计算中使用的是补码
//2是码值0-00000010
//按位取反后1-1111101
//因为是负数的补码,最后打印的结果是原码
//反码 = 补码 - 1,得到反码后,除符号位,取反
//1-00000011
int n = ~2;
System.out.println(n);
//&两位全为1,结果为1,否则为0
//2->0-00000010
//3->0-00000011
//结果->0-00010,即2
int n1 = 2 & 3;
System.out.println(n1);
// | 两位中有一个为1,结果为1,否则为0
//2->0-00000010
//3->0-00000011
//结果->0-00011,即3
int n2 = 2 | 3;
System.out.println(n2);
//转码-5->1-0000101
//反码:1-1111010
//补码:1-1111011
// ~ 后0-0000100
//4
int n3 = ~-5;
System.out.println(n3);
//13->0-00001101
//7->0-00000111
//& 后0-00000101
//5
int n4 = 13&7;
System.out.println(n4);
//5->0-0000101
//4->0-0000100
//0-0000101
int n5 = 5 | 4;
System.out.println(n5);
//^(按位异或):两位中一个为0,一个为1,结果为1,否则为0
//-3->1-11111100反码
//补码1-11111011
//3的补码 0-00000011
// 1-11111100
// 1-11111101
// 1-00000010
int n6 = -3 ^ 3;
System.out.println(n6);
}
}
分支结构
package com.sxt;
import java.util.Scanner;
public class demo {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
//int num1 = myScanner.nextInt();
char n1 = 'a';
switch(n1) {//值常量应是同一类型,或是可发生自动转换,除double,float外的数据类型
case 97:
System.out.println("fuck");
}
//default可有可无
//如果没有break,程序会继续向下执行
}
}
循环结构
java的编程思想
1,化繁为简
2,先死后生
public class Main {
public static void main(String[] args) {
abc1:for(int j = 1; j < 10; j++){
abc2:while(1>0){
abc3:for(int i = 0; i < 10; i++){
if(i == 8){
break abc2;//停止label标签的,无则就近
}
System.out.println(i);
}
}
}
}
}
eg:(int)(math.random() *100) +1生成随机数
递归
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int mikong[][] = new int[8][7];
//外围是墙用1表示
//上下
for(int i = 0; i < 7;i++){
mikong[0][i] = 1;
mikong[7][i] = 1;
}
//左右
for(int i = 0; i < mikong.length; i++){
mikong[i][0] = 1;
mikong[i][6] = 1;
}
mikong[3][1] = 1;
mikong[3][2] = 1;
System.out.println("========当前地图==========");
for(int i = 0; i < mikong.length;i++){
for(int j = 0; j < mikong[i].length; j++){
System.out.print(mikong[i][j] + " ");
}
System.out.println();
}
MiKong n = new MiKong();
n.findway3(mikong,1,1);
System.out.println("========通关当前地图==========");
for(int i = 0; i < mikong.length;i++){
for(int j = 0; j < mikong[i].length; j++){
System.out.print(mikong[i][j] + " ");
}
System.out.println();
}
}
}
class MiKong{
//路线方法
//1代表有障碍物
//2代表可以做通
//3代表死路
//行走策略 上->左->下->右
// public boolean findWay(int map[][], int x,int y){
// if(map[6][5] == 2){
// return true;
// }else {
// if(map[x][y] == 0){
// map[x][y] = 2;
// if(findWay(map, x-1, y)){
// return true;
// } else if(findWay(map, x, y-1)){
// return true;
// }else if(findWay(map, x + 1, y)) {
// return true;
// }else if(findWay(map, x, y + 1)){
// return true;
// }else{
// map[x][y] = 3;
// return false;
// }
// }else{
// return false;
// }
// }
// public boolean findWay2(int map[][], int x, int y){
// //行走策略下->右-> 上->左
// if(map[6][5] == 2){
// return true;
// }else{
// if(map[x][y] == 0){
// map[x][y] = 2;
// if(findWay2(map, x + 1, y)){
// return true;
// }else if(findWay2(map, x, y + 1)){
// return true;
// }else if(findWay2(map,x -1, y)){
// return true;
// }else if(findWay2(map, x, y - 1)){
// return true;
// }else{
// map[x][y] = 3;
// return false;
// }
// }else{
// return false;
// }
// }
// }
//行走策略 上->右->下->左
public boolean findway3(int map[][],int x, int y){
if(map[6][5] == 2){
return true;
}else{
if(map[x][y] == 0){
map[x][y] = 2;
if(findway3(map,x - 1, y)){
return true;
}else if(findway3(map, x, y + 1)){
return true;
}else if(findway3(map, x + 1, y)){
return true;
}else if(findway3(map, x, y - 1)){
return true;
}else{
map[x][y] = 3;
return false;
}
}else{
return false;
}
}
}
}
方法的重载
1,方法名相同;
2,形参不同
可变参数
java允许同一个类中多个同名同功能但参数个数不同的方法,封装成一个方法
访问修饰符 返回类型 方法名(数据类型 … 形参名)
细节:可变参数的实参可以为零个或多个
实参可以为数组
可变参数的本质是数组
可变参数与普通类型一起放在形参列表,要保证可变参数为最后一个
一个形参列表只能有一个可变参数
对象分配机制
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Person p = new Person(18, "fuck");
}
}
class Person{
int age = 90;
String name;
public Person(int pAge, String pName){
age = pAge;
name = pName;
}
}
//流程分析
//1.加载Person类信息,只会加载一次
//2.在堆中分配空间(地址)
//3.完成对象的初始化,3.1默认初始化,3.2显示初始化,3.3构造器初始化
//在堆中的地址,返回给p(p是对象名,也可易理解为对象的引用)
构造器
构造器没有返回值,构造名称与类名一致
构造器完成对对象的初始化,并不是创建对象
构造器可有多个,构造器重载
自动调用构造器
如果一个类没有定义构造器,Java会为其提供一个默认的无参构造器。
如果一个类定义了构造器,但没有定义无参构造器,那么在创建对象时必须使用参数来调用构造器。
this
1,this关键字可以访问本类的属性,方法,构造器
2,this用于区分当前类的属性和局部变量
3,访问构造器语法:this(参数列表);注意只能在构造器中使用,且必须放在第一条语句
4,this只能在类定义的方法中使用