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只能在类定义的方法中使用
3598
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
