JAVA 2-10

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量218 收藏
点赞数
分类专栏： # 2023前历史记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39081114/article/details/105546085
版权

2.概述

2.1计算机语言概述

  • 什么是计算机语言：

  • 计算机语言是人于计算机之间通讯的语言

  • 什么是机器语言：

  • 由‘0’和‘1’组成的语言，是可以直接被计算机硬件直接识别的语言。

  • 汇编语言

  • 用简介的英文字母，字符串替代特定的指令的二进制串。运行时最终转换为机器语言，应用于操作系统的核心，如linux内核，工业控制设备等

  • 高级语言

  • 接近于数学语言或人的自然语言，不依赖于计算机；

  • 优点：降低移植的成本，缩短了开发周期；

  • 高级语言可分为非结构化语言，结构化语言和面向对象语言；

  • 非结构化语言：按顺序排列的命令，每句占有一行，且有对应的标签；

  • 结构化语言：强调对代码的封装，封装于函数中；

  • 面向对象语言：最主流的语言，可以实现更高一级的抽象与封装，且提供了多态与继承功能，具有更好地扩展性与重用性；

2.2 Java

  • Java入门

  • Java SE：Java平台标准版

  • Java EE：平台标准版

  • Java EE：Java微型版

  • Java运行机制：包括编译和解释两个部分；

  • JDK，JRE，JVM的关系

  • JDK包含JRE，JRE包含JVM

  • JAR：Java Archive 与平台无关的文件格式，可以将多个文件组合为一个压缩软件；

  • 设置环境变量

  • 系统环境：JAVA_HOME C:Program Files\Java\jdk 1.7.0_25;

  • 用户环境：Path %JAVA_HOME%\bin;

  • 用户环境：CLASS_PATH %JAVA_HOME%\lib;

  • 分为三步：先设置总路径：JAVA_HOME，设置命令路径：Path，最后加载类路径：CLASS_PATH；

  • Java的包命名：企业+企业名+当前项目+文件名
    如：com.eoe.basic.day01;

2.3 Eclipse(集成开发环境)

  • Eclipse开发：

  • 文字编辑：Preferences -> Appearance -> Color and Font -> Basic -> Text Font -> Edit

  • Eclipse来创建Java项目

  • New -> Java :
    Project Name：corejava 确定即可；
    在src中创建包：com.jikexueyuan.ch02；
    包中创建类：Name Test01；

  • Java项目

  • Java 项目结构：
    Windows -> Show View -> Navigator；
    右击项目名 ->Properties ->Resource；

  • 项目的导出

  • 可以在workspace中；

  • 右击项目名： -> Export -> General -> Archive File -> next (type filter text) -> To archive file ；

  • 项目的导入

  • 删除：勾选删除项目磁盘中的文件。

  • 导入：右键 -> Import -> General -> Existing Projects into workspace, next ->非压缩： Select root directory ， 压缩：select archive file : 选择corejava.zip ->导入成功。

2.4 Eclipse 快捷键
  • syso + Alt + \ 可以直接调用输出：System.out.println();
  • Eclipse ->Preference ->编辑器 -> 文本编辑器（显示行号）
  • Alt + Shift + M可以实现设置方法
  • Source -> Getter and Setter 可以设置get方法和set方法
  • 断点 + debug模式调试
  • 设置断点；
  • 在debug模式下运行；
  • 单步执行(F5或Step in)；

3.Java类方法详解

3.1 static 关键字(类方法与静态方法)
  • 由static修饰的方法为静态方法和类方法；
  • 由static修改的变量被称为静态变量，也称为类变量。静态变量定义的位置是在所有方法之外。
  • 静态方法和静态变量都是从磁盘加载至内存后被创建。与类同时存在，同时消亡。
  • 静态变量又称为类的成员变量，在类中时全局变量，也可以被类中所有方法调用。
  • 静态变量的值可由JVM自动初始化，以下是各类型变量初始化列表。
  • 实例
import java.util.Scanner;

public class Test01 {
	
	static String name;
	static char sex;
	static int age;
	static double height;
	static String type;
	public static void main (String[] args) {
		//张飞，男，豪放
		Scanner scan = new Scanner(System.in);
		System.out.print("姓名：");
		name = scan.next();
		System.out.print("性别：");
		sex = scan.next().charAt(0);
		System.out.print("年龄：");
		age = scan.nextInt();
		System.out.print("身高：");
		height = scan.nextDouble();
		System.out.print("性格：");
		type = scan.next();
		System.out.print("嗨， 大家好！ 我叫" + name);
		System.out.print(", 今年" + age +"岁");
		System.out.print(", 身高" + height +"米");
		System.out.print(", 我是一个" + type + sex + "士。");
	}

}
3.2 定义无参方法
  • Java代码通常封装于类中；
  • 无参方法的格式：
static void 方法名() {
      方法体-方法中的代码块;
}
  • 定义方法的好处：
  • Java代码通常在方法中编写；
  • 实现模块化编程，具有不同功能的代码封装于不同方法中，便于去管理，编程；
  • 具有复用价值；
  • 实例：
import java.util.Scanner;

public class Test02 {
	
	static String name;
	static char sex;
	static int age;
	static double height;
	static String type;
	static void  input() {
		//张飞，男，豪放
		Scanner scan = new Scanner(System.in);
		System.out.print("姓名：");
		name = scan.next();
		System.out.print("性别：");
		sex = scan.next().charAt(0);
		System.out.print("年龄：");
		age = scan.nextInt();
		System.out.print("身高：");
		height = scan.nextDouble();
		System.out.print("性格：");
		type = scan.next();
		System.out.print("嗨， 大家好！ 我叫" + name);
		System.out.print(", 今年" + age +"岁");
		System.out.print(", 身高" + height +"米");
		System.out.print(", 我是一个" + type + sex + "士。");
		scan.close();
		System.out.println();
	}
	
	public static void main (String[] args) {
		input();
		System.out.print("嗨， 大家好！ 我叫" + name);
		System.out.print(", 今年" + age +"岁");
		System.out.print(", 身高" + height +"米");
		System.out.print(", 我是一个" + type + sex + "士。");
		System.out.println("\n");
		input();
		System.out.print("嗨， 大家好！ 我叫" + name);
		System.out.print(", 今年" + age +"岁");
		System.out.print(", 身高" + height +"米");
		System.out.print(", 我是一个" + type + sex + "士。");
	}
	
}
3.3 定义带参方法
  • 定义格式：
static void 方法名(类型1   变量1， 类型2    变量2....) {
      方法体-方法中的代码块;
}
  • 带参方法的好处：可接收外界传递的数据，使方法能处理更为复杂的问题；
  • 实例：
import java.util.Scanner;

public class Test03 {

	static String name;
	static char sex;
	static int age;
	static double height;
	static String type;
	static void  input() {
		//张飞，男，豪放
		Scanner scan = new Scanner(System.in);
		System.out.println("姓名：");
		name = scan.next();
		System.out.println("性别：");
		sex = scan.next().charAt(0);
		System.out.println("年龄：");
		age = scan.nextInt();
		System.out.println("身高：");
		height = scan.nextDouble();
		System.out.println("性格：");
		type = scan.next();
		
		/*
		 * NoSuchElementException
		 * 不能用.close()方法是因为，每次使用Scanner创建的对象都是由System.in封装而来
		 * 实际上每次创建的对象都是用同一个输入流。
		 * 调用.close()方法实际上是System.in.close()。
		 * */
		//scan.close();
	}
	
	public static void main (String[] args) {
		input();
		System.out.print("嗨， 大家好！ 我叫" + name);
		System.out.print(", 今年" + age +"岁");
		System.out.print(", 身高" + height +"米");
		System.out.println(", 我是一个" + type + sex + "士。");
		feeling("我捡到了500万","哈哈。。。");
		input();
		System.out.print("嗨， 大家好！ 我叫" + name);
		System.out.print(", 今年" + age +"岁");
		System.out.print(", 身高" + height +"米");
		System.out.println(", 我是一个" + type + sex + "士。");
		feeling("我失恋了","呜呜。。。");
		
	}

	static void feeling(String cause, String content) {
		System.out.println(cause);
		System.out.println(content);
	}
	
}
3.4 定义带参方法
  • Java中的Math定义了许多的带返回值方法：
  • 如：double Math.sqrt(double value)；
  • Java允许自定义带返回值的方法
static void 方法名(类型1   变量1， 类型2    变量2....) {
      方法体-方法中的代码块;
      return 数据;
}
  • 实例
public class Test04 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println("3.784保留两位小数位"+ pround(3.784,2));
	}
	
	static double pround(double value, int index) {
		//1.将值乘以10的n次幂
		double vpow = value * Math.pow(10, index);
		//2.对小数点后进行四舍五入
		double result = Math.round(vpow);
		//3.还原小数
		result = result / Math.pow(10, index);
		return result;
	}

}

4.变量与数据类型

4.1 数据类型初阶
  • Java定义了基本的数据类型，引用数据类型，自定义类型；
  • 常用为八种基本数据类型和引用数据类型的String类型
  • 栈空间
  • 效率高，先进先出的特点，JVM通常将基本数据类型的数据放入栈中；
  • 堆空间
  • 效率较低，随机分配内存，可存储大容量的数据；
4.2 变量
  • 变量可分为：
  • 可变的量；
  • 常量：不可变的量；
  • 字面量：常量与变量具体存储的量；
  • 变量的命名
  • 首字母为英文字母，$或下滑线；
  • 由字母、数字或下滑线组成
  • 首字母不大写（尽量），不用中文
  • 非关键字
  • 用变量简化计算：
  • 实例：用变量保存多种类型的数据：
public class Test02 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String phoneType = "小米";
		String operationSystem = "android";
		short numberCpu = 2;
		double price = 1999.0;
		System.out.print("手机品牌：" + phoneType + "\n操作系统：" + operationSystem
				+ "\nCPU数：" + numberCpu + "\n价格:" + price);
	}

}

  • 变量的作用域

  • Java用一对大括号作为语句块的范围，为作用域；

  • 离开了作用域，变量所分配的内存空间将会被JVM回收

  • 实例：

public class Test03 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		{
			String name = "张三";
			System.out.println(name);
		}
		/*
		 * 因为之前的“张三”作用于在大括号中，离开大括号，name将被JVM回收
		 * 因此运行不会出错
		 * 大括号表示变量的作用域
		 * */
		String name = "李四";
		System.out.println(name);	
		
		//相反则不行如：
//		String name = "李四";
//		System.out.println(name);
//		{
//			String name = "张三";
//			System.out.println(name);
//		}
	}

}
4.3 基本数据类型的包装类
  • 八大基本数据类型的包装类：
  • byte 对应于 Byte
  • short 对应于 Short
  • int 对应于 Integer
  • long 对应于 Long
  • float 对应于 Float
  • double 对应于 Double
  • char 对应于 Character
  • boolean 对应于 Boolean
  • 包装类中包装了很实用的方法和常量：
  • 如：Byte.MIN_VALUE；
  • 包装类在集合中，是用来定义集合元素的类型；
  • 实用型类方法：
//int类型实用型
1. Integer.MIN_VALUE   //int最小值
2. Integer.MAX_VALUE   //int最大值
3. int Integer.parseInt(String sInteger);
4. String Integer.toBinaryString(int value);
5. String Integer.toHexString(int value);  //十六进制

//int类型实用型
1. double Double.parseDouble(String sDouble);
2. double Double.MAX_VALUE;
3. String Double.toBinaryString(double value); 
4. String Double.toHexString(double value);
  • 实例：
public class Test04 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println("Int 最大值：" + Integer.MAX_VALUE);
		System.out.println("Int 最小值：" + Integer.MIN_VALUE);
		System.out.println("字符转换：32149   " + Integer.parseInt("32149"));
		System.out.println("转化为二进制：32149   " + Integer.toBinaryString(32149));
		System.out.println("转化为十六进制：32149   " + Integer.toHexString(32149));
		
		
		System.out.println("Byte 最大值：" + Byte.MAX_VALUE);
		System.out.println("Byte 最小值：" + Byte.MIN_VALUE);
		System.out.println("字符转换：117   " + Byte.parseByte("117"));
	}

}
4.4 八大数据类型
  • Java地层中，byte、short均可以通过转化为int计算；
  • float与double 类型都是以约数进行表示；
  • char类型：
  • 可以为英文，汉子，字符，数字，’\n’；
  • Java底层中用16为表示char，其编码格式为Unicode编码；
  • Java对char的处理是先将其转化为int类型；
  • 类型转化：
  • 小类型向大类型转化时，若小类型精度> 大类型精度，则会丢失精度；
  • 大类型向类型转化时，注意边界数问题；
  • 实例：
public class Test05 {
	public static void main(String[] args) {
		
		for (int i=0, count=0; i<128; i++,count++) {
			System.out.print((char)i+":"+i+"\t");
			if ((count+1) % 10 ==0)
				System.out.println("\n");
			System.out.println("\"");
		}
	}
}

5.逻辑运算

5.1逻辑运算的种类
  • 逻辑运算在关系运算之上，其返回结果为true或false；
  • 常用逻辑运算为：&, &&; |, ||; !
  • 逻辑运算又分为长路逻辑运算和短路逻辑运算；
  • 非>与>或
5.2长路、短路“与”运算
  • &
  • 在两边为整数时，是逐位与运算；
  • 在两边为关系运算时，是逻辑运算；
  • 长路与运算，会把两边的关系运算的结果都计算出来；
  • &&
  • 当左边为关系运算为false时，不再计算右边；
5.3长路、短路“或”运算
  • |
  • 在两边为整数时，是逐位或运算；
  • 在两边为关系运算时，是逻辑运算；
  • 长路或运算，会把两边的关系运算的结果都计算出来；
  • ||
  • 当左边为关系运算为true时，不再计算右边；

6 数组

6.1 数组的声明与内存分配
  • 形式一：type arrayName[];
  • 形式二：type[ ] arrayName;
  • 为数组分配内存，如果没有分配内存，则无法访问元素，通常用new类分配内存；
  • 实例：
public class ArrayDemo1 {
	public static void main (String[] args){
		int score[];
		score = new int[3];
		for (int i=0; i<3; i++) {
			System.out.println(score[i]);
		}
		
		for (int i = 0; i < score.length; i++) {
			score[i] = 2*i + 1;
			System.out.println(score[i]);
		}

	}
}
6.2 数组的初始化
  • 数组的初始化包括静态初始化和动态初始化；
  • 实例
public class ArrayDemo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		int array[] = {44, 24, 25, 6, 37};
		int max = array[0], min = array[0];
		for (int i = 0; i < array.length; i++) {
			if(array[i] > max) {
				max = array[i];
			}
			if (array[i] < min) {
				min = array[i];
			}
		}
		System.out.println("min="+min);
		System.out.println("max="+max);
	}

}
6.3 二维数组
  • 二维数组声明与一维数组类似，用new来分配内存；
  • 如：type arrayName[][] = new type[行][列]；
  • 静态初始化：
  • 如：type arrayName[] = { {value 1} , {value 2} , {value 3} }；
public class ArrayDemo4 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int score[][];
		score = new int[5][5];
		for (int i = 0; i < 5; i++) {
			for (int j = 0; j < 5; j++) {
				System.out.print(score[i][j]+"    ");
			}
			System.out.println();
		}
	}

}
6.4 冒泡排序和选择排序
import java.util.Scanner;
/*
 * 冒泡排序
 */
public class ArrayDemo3 {
	public static void main (String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入整数个数：");
		int N = scan.nextInt();
		int array[] = new int[N];
		System.out.println("请输入数组");
		for (int i = 0; i < N; i++) {
			array[i] = scan.nextInt();
		}
		scan.close();
		
		//冒泡排序
		int temp;
		for (int i = N-1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				if (array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array [j+1];
					array[j+1] = temp;
				}
			}
		}
		for (int i = 0; i < N; i++) {
			System.out.println("array=" + array[i]);
		}
		
		/*
		 * 选择排序
		 */
		for (int i = 0; i < N-1; i++) {
			for (int j = i+1; j < N-1; j++) {
				if (array[i] > array[j]) {
					temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
		
	}
	
}

7. 类与对象概念的使用

7.1 Java方法的创建与重载
  • 方法的定义：可以重复调用的代码段；
  • 方法的重载：方法名称相同，类型相同，参数的类型和个数不同，通过传递参数的个数和类型来完成不同的功能。
public void tell() {};
public void tell(int i, String s) {};

class Person {
	public int age;
	public String name;
	public void tell () {
		System.out.println("ΠΥΓϋ£Ί" + name);
		System.out.println("ΔκΑδ£Ί" + age);
	}
}

public class ClassTemo {
	public static void main(String[]  args) {
		Person per = new Person();
		per.name = "ΥΕΘύ";
		per.age = 23;
		per.tell();
	}
}
7.2 类的创建以及类与对象的关系
  • 类与对象的关系：
  • 类是对某一事物的描述，是抽象的，概念的意义；
  • 对象是实际存在的该类事物的每一个个体，也称为实例；
  • 实例：
class People {
	int age;
	String name;
	public People (String name, int age) {
		System.out.println("姓名：" + name + "年龄：" + age);
	}
	public People (String name) {
		System.out.println("姓名:" + name);
	}
}
public class ClassDemo3 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		People per = new People("张三", 15);
		People per2 = new People("张三");
	}

}


public class ClassTemo {
	public static void main(String[]  args) {
		Person per = new Person();
		per.name = "ΥΕΘύ";
		per.age = 23;
		per.tell();
	}
}
7.3 Java面向对象的思想的编程
  • 程序的发展历程：面向过程→面向对象
  • 面向过程：不去想什么样的盒子，随机制作盒子；
  • 面向对象：先想好要制作什么样的盒子，再去找对应的工具制作；
  • 面向对象三大特性：
  • 封装性：对外部不可见；
  • 继承：扩展类的功能；
  • 多态：方法的重载，对象的多类性；
  • 实例：
在这里插入代码片
7.4 Java方法的递归调用
  • 实例：
public class MethodDemo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println("1+2+..+100=" + addNum(100));
	}
	public static int addNum(int num) {
		if (num == 1) {
			return num;
		}else {
			return num + addNum(num-1);
		}
	}

}

8. 面向对象的基本特性

8.1 封装性的使用
  • 封装的目的：保护属性与方法不被外部看见；
  • 封装的实现：为属性和方法进行的封装是通过private关键字来声明的；
8.2 匿名对象的使用
  • 匿名对象是指没有名字的对象，如果程序中只使用了一次该对象，可使用匿名对象的方式；
8.3 java构造对象的使用
  • 构造方法的特点：
  • 不需要返回值类型；
  • 与类名一致；
  • 自动执行；
  • 无法调用；
  • 构造方法的功能：为类中属性初始化；
  • 构造方法可以重载

9. Java对象：继承

9.1 继承
  • 继承的基本概念
  • 扩展父类的功能；
  • Java中通过extends关键字完成继承；
  • Java继承的限制：
  • Java中只允许单继承
  • 子类不能直接访问父类的私有成员；
  • 子类对象的实例化：
  • 在子类对象实例化之前，必须先调用父类的构造方法，之后调用子类构造方法；
  • 实例
class People {
	private int age;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}
class Worker extends People{
	public void tell() {
		System.out.println("年龄"+ getAge());
	}
}
public class ExtendsDemo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Worker work = new Worker();
		work.setAge(23);
		work.tell();
	}

}
9.2 方法的重写与super关键字
  • 重写：子类中定义了与父类同名的方法；
  • 定义：方法名称相同，返回值类型相同，参数相同；
  • 限制：子类不能有被父类更低的访问权限；
  • 访问权限：private < default < public;
  • private在当前类中可以被访问；default在当前包中可以被访问；public在整个工程中都可以被访问；
  • super关键字：强行调用父类的方法执行；
  • 实例
class Father {
	private int age;
	private String name;
	public Father(){
		System.out.println("父类的构造方法");
	}
}
class Son extends Father{
	public Son() {
		System.out.println("子类的构造方法");
	}
}
public class ExtendsDemo3 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Son s =new Son();
	}

}


class A{
	public void tell() {
		System.out.println("我是tell方法");
	}
	private void say() {
		
	}
	void print() {
		
	}
}
class B extends A{
	public void tell() {
		super.tell();
		System.out.println("我重写了tell方法");
	}
}
public class ExtendsDemo4 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

	}

}
9.3 Java的重写与重载的区别
  • super关键字：强行调用父类的方法执行；
  • super不一定在重写中使用，也可以表示哪些方法是从父类中继承过来的；
  • 重载
  • 方法名称相同，参数类型或者个数不同；
  • 对权限没有要求；
  • 发生在一个类中；
  • 重写
  • 方法名称，参数类型，返回类型均相同；
  • 子类不能拥有比父类更低的访问权限；
  • 发生在继承中；

10. Java面向对象：多态

  • 多态性：
  • 方法的重载与重写；
  • 对象的多态性；
  • 对象的多态性：
  • 向上转型：程序会自动完成；
    如：父类 父类对象 = 子类实例；
  • 想下转型：强制类型转换：
    如：子类 子类对象 = （子类） 父类实例；
  • 在Java中可通过instanceof关键字判断一个对象是否为一个类的实例；
  • 无论何时，不要去继承一个已经完成的类；
  • 实例：
class A1 {
	public void tell1() {
		System.out.println("A1---tell1");
	}
}
class B1 extends A1 {
	public void tell2() {
		System.out.println("B1---tell2");
	}
}
class C1 extends A1 {
	public void tell3() {
		System.out.println("C1---tell3");
	}
}
public class PolDemo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		say(new B1());       //这里自动进行了类型转换：A1 a = new B1();
		say(new C1());       //这里自动进行了类型转换：A1 a = new C1();
	}
	public static void say(A1 a) {
		a.tell1();              //每次调用类型A,B,C,自动输出tell1();
	}
	
//	public static void say(B1 b) {
//		b.tell1();              //每次调用类型A,B,C,自动输出tell1();
//	}
//	public static void say(C1 c) {
//		c.tell1();              //每次调用类型A,B,C,自动输出tell1();
//	}
	

}
Bang ya
关注
专栏目录
java-7-openjdk-amd64
07-15
2. 解包 mkdir /opt/jdk/ tar -zxvf java-7-openjdk-amd64.tar.gz -C /opt/jdk/ 3. 配置编译环境 JAVA_HOME=/opt/jdk/java-7-openjdk-amd64 PATH=$JAVA_HOME/bin:$PATH CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_...
自学javase的回顾（2/10）
weixin_47592060的博客
11-28 314
自学javase的回顾（2/10） 1. java数据类型和类型转换 2. java进制换算和字符编码 3. java基本单位变量 4. java运算符 一. java数据类型和类型转换 java数据类型 1）java数据类型分为基本数据类型和引用数据类型 A、基本数据类型包括八大基本数据类型 B、引用数据类型包括字符串String，类class，接口interface，数组array等 2)数据类型有什么用？？？ 1、会指导变量该分配多大的储存空间。（数据字面值必须和变量数据类型一致，否则报错） 2、决定
彻底搞懂Java中的＞＞,＜＜,＞＞＞
h2763246823的博客
02-15 626
Java中区分>>,<<,>>>前言有符号数的表示（补充了解）1.原码2. 反码3. 补码算术右移，算术左移，逻辑右移1. 总述2.逻辑右移详解正数负数测试代码写在最后 前言 首先需要知道在Java基本数据类型中不存在无符号数，即全为有符号数，>>,<<,>>>分别表示算术右移，算术左移，逻辑右移(无符号右移) 对于了解原码，反码，补码的读者可以直接跳过“有符号数的表示”部分 有符号数的表示（补充了解） 1.原码 最左边一
java 10.1/10.2/10.3 总结
qaqaqaerw的博客
10-11 1371
java 三大流程控制 1. 顺序控制 依次执行我们的代码。 2. 条件控制 a. 目的 ： 对程序执行，一些不可预知的流程，进行一个预先判断. b. 条件:条件具有真假的特性。而且只可能为真，或者为假。 c. java条件控制有四种手段: (1)if语句 结构:      if(条件){             //实现我们的逻辑                 } (2
java 2 10_10.2java
weixin_30691643的博客
02-25 128
1.“==”与equals的区别== 是引用是否相等，equals是内容相等Integer a = new Integer(1);Integer b = new Integer(1);if (a = b)... //错误if(a.equals(b))... //正确public class TestEqualsString {public static void mai...
JAVA单排日记-2020/2/10-MySQL-多表查询-练习
wangzilong1995的博客
02-10 193
-- 部门表 CREATE TABLE dept ( id INT PRIMARY KEY PRIMARY KEY, -- 部门id dname VARCHAR(50), -- 部门名称 loc VARCHAR(50) -- 部门所在地 ); -- 添加4个部门 INSERT INTO dept(id,dname,loc) VALUES (10,'教研部','北京'), (20,'...
alipay-sdk-java-all
06-04
alipay-sdk-java-allalipay-sdk-java-allalipay-sdk-java-allalipay-sdk-java-allalipay-sdk-java-allalipay-sdk-java-allalipay-sdk-java-allalipay-sdk-java-allalipay-sdk-java-allalipay-sdk-java-allalipay-sdk...
aws-java-sdk-ec2-1.11.277.jar
04-27
aws-java-sdk-ec2-1.11.277.jar
wsdl2java源码-wsdl2java:wsdl2java
06-05
wsdl-2-java 插件相同的选项。 插件二进制文件可从 bintray 下载： 问题 如果您对插件有任何问题，请在 github 上提交问题， 贡献 只要他们是理智的，就欢迎贡献。 贡献者 尼尔斯·拉斯加德 马茨·福格利， 托本·...
java-1.8.0-openjdk
07-19
5. **文件名称列表**: "java-1.8.0-openjdk-1.8.0.292-2.b10.dev.redhat.windows.x86_64" 是整个压缩包的主文件名，它包含了所有 OpenJDK 的组件，如 bin 目录下的可执行文件、lib 目录下的类库、conf 配置文件等。...
java 2-10进制的随意转换
back_ywt的博客
03-06 383
先把任意进制转换成为10进制，然后转从10进制换成n进制
java中"% "与 "/ "之间的区别
Ryan_wangzi的专栏
08-20 3500
%是求模运算符 /是除运算符 二者都是双目运算符。 它们之间的区别就是： %是求余运算，即2%10=2，10%2=0，10%3=1。 /是普通的除号，即10/2=5
在Java编程中%和/的区别
m0_63926154的博客
09-11 5086
简单理解：在Java中/可以简单理解为取整，而%为取余。小细节：在js中/不收拾取整会出现小数所以要注意一下。在编程中经常会看到%和/这里要区分一下它俩的区别。
Java编程入门与应用 P42——例2.10（编写 一个程序，使用户可以从键盘输入两个数，并判断这两个数之间的大小）
乖珑珑的博客
03-24 756
Java编程入门与应用 P42——例2.10 编写 一个程序，使用户可以从键盘输入两个数，并判断这两个数之间的大小 //调用类 import java.util.Scanner; /** * Java编程入门与应用 P42——例2.10 * 编写 一个程序，使用户可以从键盘输入两个数，并判断这两个数之间的大小 */ public class compare_num_size { //主方法 public static void main(String[] args){ .
关于java位运算符&,~,^,|,<<,>>的整理(包含二进制与十进制的转换)
热门推荐
lsr40的博客
09-18 1万+
要讲java一些奇奇怪怪的运算符号之前，必须先了解二进制，因为这些看不懂的运算符都是基于二进制运算的 计算机里二进制的运算，往往比十进制运算来的快。 首先了解下转换规则（相互转换）： 转码之前，有一些名词概念： 1、原码 一个正数，按照绝对值大小转换成二进制数，称为原码 2、反码 将二进制数按位取反，所得的新二进制数称为原二进制数的反码 其实就是把原码中的0变为1,1变为0
java怎么表示10 2_java -Xmx1G是否表示10 ^ 9或2 ^ 30字节？
weixin_33167456的博客
02-25 501
小编典典简短的答案：JVM命令行参数使用的所有内存大小均以传统的二进制单位指定，其中千字节为1024字节，其他以1024为底的幂。长答案：在命令行参数的此文档页面上，以下内容适用于所有接受内存大小的参数：例如，设置大小为8 GB，您可以指定8g，8192m，8388608k，或8589934592作为参数。对于-Xmx，它提供了以下特定示例：下面的示例演示如何使用各种单位将分配的最大内存大小设置为...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 375
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 891
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
Java Switch-Case 两例题解析与实现
资源摘要信息:"switch-java-switch-...以上两个例题对应的具体实现代码分别保存在文件"SwitchCaseTest2.java"和"SwitchCaseTest1.java"中，通过这两个文件，可以进一步学习和理解switch-case语句在Java中的实际应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值