首页 文章 精选 留言 我的

精选列表

搜索[基础搭建]，共10000篇文章
优秀的个人博客,低调大师

Android 基础题目

1. BroadcastReceiver 在UI thread？ BroadcastReceiver 总是在UI thread， If you register yourBroadcastReceiverusing a validHandlerrunning on a different thread: For example: 1 2 3 4 5 HandlerThread handlerThread = new HandlerThread( "ht" ); handlerThread.start(); Looper looper = handlerThread.getLooper(); Handler handler = new Handler(looper); context.registerReceiver(receiver, filter, null , handler); // Will not run on main thread 参考 2. 为什么要使用IntentServie IntentService是Service的子类，比普通的Service增加了额外的功能。先看Service本身存在两个问题： Service不会专门启动一条单独的进程，Service与它所在应用位于同一个进程中； Service也不是专门一条新线程，因此不应该在Service中直接处理耗时的任务； IntentService特征 会创建独立的worker线程来处理所有的Intent请求； 会创建独立的worker线程来处理onHandleIntent()方法实现的代码，无需处理多线程问题； 所有请求处理完成后，IntentService会自动停止，无需调用stopSelf()方法停止Service； 为Service的onBind()提供默认实现，返回null； 为Service的onStartCommand提供默认实现，将请求Intent添加到队列中； 本文转自Work Hard Work Smart博客园博客，原文链接：http://www.cnblogs.com/linlf03/p/6429338.html，如需转载请自行联系原作者
2017-10-13
优秀的个人博客,低调大师

Android DEX 基础

转载请标明出处：http://www.cnblogs.com/zhaoyanjun/p/5736305.html本文出自【赵彦军的博客】 1、什么是dex？ 简单说就是优化后的android版.exe。每个apk安装包里都有。相对于PC上的java虚拟机能运行.class；android上的Davlik虚拟机能运行.dex。为何要研究dex格式？因为dex里面包含了所有app代码，利用反编译工具可以获取java源码。理解并修改dex文件，就能更好的apk破解和防破解。 2、dex好处 dex文件有个天大的好处：它可以直接用DexClassLoader类加载，这叫动态加载。于是我们只要在dex上加壳，在程序运行时脱壳，就可以规避静态反编译的风险。 3、一般的反编译流程是什么样子的。 1、下载apk文件，然后解压 ，得到 class.dex 文件 2、用dex2jar 把 class.dex 还原成classes-dex2jar.jar 文件 3、用jd-gui.exe 把classes-dex2jar.jar 文件打开，就可以看到源码了。 4、Android 为什么会出现 65536限制问题？ 在Android系统中，一个App的所有代码都在一个Dex文件里面。Dex是一个类似Jar的包，存储了很多Java编译字节码的归档文件。因为Android系统使用Dalvik虚拟机，所以需要把使用Java Compiler编译之后的class文件转换成Dalvik能够执行的class文件。这里需要强调的是，Dex和Jar一样是一个归档文件，里面仍然是Java代码对应的字节码文件。当Android系统启动一个应用的时候，有一步是对Dex进行优化，这个过程有一个专门的工具来处理，叫DexOpt。DexOpt的执行过程是在第一次加载Dex文件的时候执行的。这个过程会生成一个ODEX文件，即Optimised Dex。执行ODex的效率会比直接执行Dex文件的效率要高很多。但是在早期的Android系统中，DexOpt有一个问题，也就是这篇文章想要说明并解决的问题。DexOpt会把每一个类的方法id检索起来，存在一个链表结构里面。但是这个链表的长度是用一个short类型来保存的，导致了方法id的数目不能够超过65536个。当一个项目足够大的时候，显然这个方法数的上限是不够的。尽管在新版本的Android系统中，DexOpt修复了这个问题，但是我们仍然需要对老系统做兼容。
2017-05-16
优秀的个人博客,低调大师

Web服务基础

一、HTTP概述 HTTP是HyperText Transfer Protocol的缩写，即超文本传输协议。HTTP是应用层协议，同其他应用层协议一样，是为了实现某一类具体应用的协议，并由某一运行在用户空间的应用程序来实现其功能。HTTP是一种协议规范，这种规范是记录在文档上的，为真正通过HTTP协议进行通信的HTTP的实现程序。我们知道，HTTP协议是基于C/S架构的进行通信的，而HTTP协议的服务器端实现程序有httpd、nginx等，其客户端的实现程序主要是Web浏览器，例如Firefox、Internet Explorer、Google chrome、Safari、Opera等，此外，客户端的命令行工具还有elink、crul等。Web服务是基于TCP的，因此为了能够随时响应客户端的请求，Web服务器需要监听在80/TCP端口。这客户端浏览器和Web服务器之间就可以通过HTTP协议进行通信了。 二、IANA定义的端口 我们知道，Web服务器为了让所有客户浏览器程序能够与之通信，通常都需要监听在80端口。用户在浏览器上键入URL时，例如：www.baidu.com，默认端口就是80。这一端口是由IANA（InternetAssigned Numbers Authority）分配指定的。另外，IANA是由ICANN管理的，其定义的端口如下： ①0-1023：众所周知的端口，永久地分配给固定的应用使用，这些端口的使用需要特定的应用去注册，属于特权端口，例如Web服务的80/tcp，FTP的21/tcp等。该类端口只有系统管理员才有权限启用，并让进程监听，而普通用户则没有权限。 ②1024-41951：亦为注册端口，但要求不是特别严格，这些端口分配给程序，并注册为某个应用使用，但这些应用并不是很常见，例如mysql服务的3306/tcp，memcache的11211/tcp等。 ③41952+：客户端程序随机使用的端口，为动态端口，或私有端口。在Linux上该类端口范围定义在/proc/sys/net/ipv4/ip_local_port_range中。 三、BSD Socket BSD Socket最早是BSD Unix系统的进程通信机制。Socket即为套接字，作为IPC（Inter-Process Communication，进程间通信）的一种实现，允许位于不同主机上（也可以是同一主机上）的进程间通信机制。Socket可理解为“插座”，只要电线插上了这个“插座”，就可以进行通信了。Socket本质上应该是Socket API，它封装了内核中socket通信相关的通信细节，也就是封装了通信子网（传输层、网络层、数据链路层、物理层）要实现的具体的通信细节，而程序员通过调用Socket API就可以编写能够实现网络通信的程序了。 Socket描述的是IP地址和端口。不同的服务所对应的端口号不同，每种服务需要绑定并监听在一个端口上，打开一个Socket，而客户端可以通过一个Socket跟服务器上的Socket建立连接，这样二者就能实现通信了，我们把正处于通信状态的一对套接字称为已连接套接字。总的来说，Socket是应用层与传输层之间的桥梁，如图。 前面提到，Socket是对IP地址和端口号的描述，一个IP地址+一个端口就是一个套接字(socket)。根据Socket在传输层使用的协议可分为以下三类： (1)SOCK_STREAM：tcp套接字 (2)SOCK_DGRAM：udp套接字 (3)SOCK_RAW：raw套接字 这里的raw套接字指的是在不使用任何传输层协议（例如tcp, udp等）的情况下直接通过发送或接收IP数据包实现通信的一种方式，也就是应用层直接绕过像tcp/udp这样的协议直接基于IP数据包通信。 根据Socket监听的地址格式，Socket Domain可分为： (1)AF_INET：Address Family，IPv4地址格式 (2)AF_INET6：Address Family，IPv6地址格式 (3)AF_UNIX：Address Family，同一主机上不同进程间基于Socket套接字通信所使用的一种地址格式，这种地址的表现形式就是一个套接字文件（Linux一切皆文件）；这种地址又称为Unix_SOCK. 接下来介绍TCP客户端和服务器是如何通过TCP套接字接口进行通信的。如图。 对于TCP服务器端来说，首先需要调用socket()函数，向内核注册申请创建TCP套接字(IP地址+端口)；一旦申请成功了，就要通过bind()函数绑定程序到这个套接字上；绑定之后，需要调用listen()函数，使服务器进程监听在这个套接字上，允许套接字进行连接，但此时还不能接收用户请求；只有再调用accept()函数之后才开始负责接收客户端请求，并在客户端请求到达之前一直处于阻塞状态，此时TCP服务器进程的状态为LISTEN。 对于TCP客户端来说，同样需要调用socket()函数创建套接字，但不需要监听；当客户端向服务器发起连接请求时，即调用connect()函数，其中在括号中的参数包括对方服务器的IP地址和端口；如果服务器接收连接请求，则双方进行了tcp三次握手，建立双向的虚链路，此时客户端和服务器之间的套接字处于已连接状态(ESTABLISHED)，之后的http请求/响应报文都是基于此前建立的虚链路进行发送。 在Linux上，当连接建立之后，客户端就可以在与服务器建立连接的socket文件上填写需要请求的数据，写入数据就相当于向服务器发送数据了，此过程通过调用write()函数完成；而服务器端则可以在与客户端建立连接的socket文件上读取数据，即调用read()函数，这一过程相当于接收客户端请求的数据，二者之间具体的通信细节由底层的通信子网完成。服务器读取到客户端发送过来的请求报文后，接着进行解析请求、处理请求并构建响应报文，再通过调用write()函数把响应报文写入socket文件，通过通信子网传送到客户端的socket文件上，客户端就可以通过这个socket文件得到服务器的响应报文了。如此往复循环多次，直到客户端请求断开连接（一般是由客户端主动请求断开连接，在使用keep-alive连接方式时则有可能是服务器主动请求断开连接）。 一旦客户端请求断开连接，TCP服务器通过调用read()函数读取socket文件内的断开请求数据，同意断开连接。
2017-05-04
优秀的个人博客,低调大师

Android json基础

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。 它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。 这些特性使JSON成为理想的数据交换语言。 ——JSON官网：http://www.json.org/json-zh.html 一.定义 JSON建构于两种结构： 列表内容“名称/值”对的集合（A collection of name/value pairs）。 不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。 值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。 这些都是常见的数据结构。事实上大部分现代计算机语言都以某种形式支持它们。这使得一种数据格式在同样基于这些结构的编程语言之间交换成为可能。 对象模式： {“name”: “xiaoluo”} ， 这就是一个最简单的json对象，对于这种数据格式，key值必须要是string类型，而对于value，则可以是string、number、object、array等数据类型 数组模式：这种形式被称为是jsonArray，数组是值（value）的有序集合。一个数组以“[”开始，“]”结束。值之间使用“,”（逗号）分隔。 二.解析JSON数据 Android提供的Json解析类： JSONObject： Json对象，可以完成Json字符串与Java对象的相互转换 JSONArray： Json数组，可以完成Json字符串与Java集合或对象的相互转换 JSONStringer：Json文本构建类，这个类可以帮助快速和便捷的创建JSON text， 每个JSONStringer实体只能对应创建一个JSON text JSONException：Json异常 JSONObject简单使用示例： infoMap = new HashMap<String, Object>(); try { JSONObject root = new JSONObject(stringBuilder.toString()); Iterator actions = root.keys(); //key()方法返回一个key的迭代器（String类型） while (actions.hasNext()) { String param = actions.next().toString(); Object value = root.get(param); infoMap.put(param, value); } } catch (JSONException e) { e.printStackTrace(); } 执行以上代码就将JSON中的 ”键值“ 输送到HashMap中。
2017-01-19
优秀的个人博客,低调大师

java基础学习_基础语法(下)02_day06总结

========================================================================================================================================================== 涉及到的知识点有：1：二维数组(理解) (1)二维数组的定义 (2)二维数组的格式 格式一：(自动动态初始化) 格式二：(半自动动态初始化) 格式三：(静态初始化) 面试题： (3)二维数组的案例(掌握) A:二维数组的遍历 B:二维数组的求和 C:打印杨辉三角形(行数可以键盘录入)2：两个思考题(理解) (1)Java中的参数传递问题及图解。 (2)数据加密问题。 ==========================================================================================================================================================1：二维数组(理解) (1)二维数组的定义：元素是一维数组的数组。 (2)二维数组的格式： 格式一：(自动动态初始化) 数据类型[][] 数组名 = new 数据类型[m][n]; //常用这个格式。 数据类型 数组名[][] = new 数据类型[m][n]; //该格式可以，但是很少用了。 数据类型[] 数组名[] = new 数据类型[m][n]; //该格式也可以，但是很少用了。 m表示这个二维数组有多少个一维数组。 n表示每一个一维数组的元素个数。 举例： int[][] arr = new int[3][2]; 定义了一个二维数组arr。 这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]。 每个一维数组有2个元素，可以通过arr[m][n]来获取。 即： arr[m][n] 表示获取第m+1个一维数组的第n+1个元素。 例如：arr[1][2] 表示获取第2个一维数组的第3个元素。 如下如图所示01： --------------------------------------- 格式二：(半自动动态初始化) 数据类型[][] 数组名 = new 数据类型[m][]; m表示这个二维数组有多少个一维数组。 这一次没有直接给出一维数组的元素个数，可以动态的给出。 举例： int[][] arr = new int[3][]; arr[0] = new int[2]; arr[1] = new int[3]; arr[2] = new int[1]; 如下如图所示02： --------------------------------------- 格式三：(静态初始化) 数据类型[][] 数组名 = new 数据类型[][]{ {...}, {...}, {...} }; 数据类型[][] 数组名 = { {...}, {...}, {...} }; 格式三的简化版格式 举例： int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; int[][] arr = { { 1, 2, 3 }, { 4, 5 }, { 6 } }; 如下如图所示03： 面试题： 下面定义的区别： int x, y; //定义了1个int类型的变量x，同时也定义了1个int类型的变量y。 //等价于 int x; int y; --------------------------------------- int[] x, y[]; //定义了1个int类型的一维数组x，同时也定义了1个int类型的二维数组y。 //等价于 int[] x; int[] y[]; (3)二维数组的案例(掌握): 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:二维数组的求和 int sum = 0; for(int x = 0; x < arr.length; x++) { for(int y = 0; y < arr[x].length; y++) { sum += arr[x][y]; } } C:打印杨辉三角形(行数可以键盘录入) 1 /* 2 需求：打印杨辉三角形(行数可以键盘录入) 3 4 1 5 1 1 6 1 2 1 7 1 3 3 1 8 1 4 6 4 1 9 1 5 10 10 5 1 10 11 分析：看这种图像的规律： 12 A:任何一行的第一列和最后一列都是1。 13 B:从第三行开始，除去第一列和最后一列，剩余的每一列的数据是它上一行的前一列和它上一行的本列之和。 14 15 步骤： 16 A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。 17 这个n的数据来自于键盘录入。 18 B:给这个二维数组任何一行的第一列和最后一列赋值为1。 19 C:按照规律给其他元素赋值： 20 从第三行开始，除去第一列和最后一列，剩余的每一列的数据是它上一行的前一列和它上一行的本列之和。 21 D:遍历这个二维数组。 22 */ 23 import java.util.Scanner; 24 25 class Array2Test3 { 26 public static void main(String[] args) { 27 //创建键盘录入对象。 28 Scanner sc = new Scanner(System.in); 29 30 //这个n的数据来自于键盘录入。 31 System.out.println("请输入一个数据："); 32 int n = sc.nextInt(); 33 34 //定义二维数组 35 int[][] arr = new int[n][n]; 36 37 //给这个二维数组任何一行的第一列和最后一列赋值为1 38 for(int x = 0; x < arr.length; x++) { 39 arr[x][0] = 1; //任何一行第一列 40 arr[x][x] = 1; //任何一行的最后一列 41 } 42 43 //按照规律给其他元素赋值 44 //从第三行开始，除去第一列和最后一列，剩余的每一列的数据是它上一行的前一列和它上一行的本列之和。 45 for(int x = 2; x < arr.length; x++) { 46 //这里如果 y <= x 是有个小问题的，就是最后一列的问题，因为最后一列已经给过值了。 47 //所以这里要减去1 48 //并且y也应该从1开始，因为第一列也给过值了。 49 for(int y = 1; y <= x - 1; y++) { 50 //除去第一列和最后一列，剩余的每一列的数据是它上一行的前一列和它上一行的本列之和。 51 arr[x][y] = arr[x - 1][y - 1] + arr[x - 1][y]; 52 } 53 } 54 55 //遍历这个二维数组。 56 /* 57 for(int x = 0; x < arr.length; x++) { 58 for(int y = 0; y < arr[x].length; y++) { 59 System.out.print(arr[x][y]+"\t"); 60 } 61 System.out.println(); 62 } 63 */ 64 //这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似。 65 for(int x = 0; x < arr.length; x++) { 66 for(int y = 0; y <= x; y++) { 67 System.out.print(arr[x][y]+"\t"); 68 } 69 System.out.println(); 70 } 71 } 72 } -----------------------------------------------------------------------------2：两个思考题(理解) (1)Java中的参数传递问题及图解。 基本类型：形式参数的改变对实际参数没有影响。 引用类型：形式参数的改变直接影响实际参数。 基本类型：传递的是基本类型的数据值。 引用类型：传递的是地址值。 小结：不管怎么说，都是值，即在Java中，只有值传递。 如下图所示04： (2)数据加密问题。 综合的小案例。 int index = 0; arr[index] = number % 10 = number / 1 % 10; index++; arr[index] = number / 10 % 10 = number / 10 % 10; index++; arr[index] = number / 10 / 10 % 10 = number /100 % 10; ...... --------------------------------------- int index = 0; while (number > 0) { arr[index] = number % 10; number /= 10; } 示例代码如下： 1 /* 2 把刚才的代码改进一下： 3 A:把数据改进为键盘录入 4 B:把代码改进为方法实现 5 6 7 另一个数据的测试： 8 number:1234567 9 第一步：7654321 10 第二步：2109876 11 第三步：6109872 12 13 知识点： 14 变量 15 数据类型 16 运算符 17 键盘录入 18 语句 19 方法 20 数组 21 */ 22 import java.util.Scanner; 23 24 class JiaMiDemo2 { 25 public static void main(String[] args) { 26 //创建键盘录入对象 27 Scanner sc = new Scanner(System.in); 28 29 //请输入一个数据 30 System.out.println("请输入一个数据(小于8位)："); 31 int number = sc.nextInt(); 32 33 //写功能实现把number进行加密 34 //调用 35 String result = jiaMi(number); 36 System.out.println("加密后的结果是："+result); 37 } 38 39 /* 40 需求：写一个功能，把数据number实现加密。 41 两个明确： 42 返回值类型：String 为了做一个字符串的拼接。 43 参数列表：int number 44 */ 45 public static String jiaMi(int number) { 46 //定义数组 47 int[] arr = new int[8]; 48 49 //定义索引 50 int index = 0; 51 52 //把number中的数据想办法放到数组中 53 while(number > 0) { 54 arr[index] = number % 10; 55 index++; 56 number /= 10; 57 } 58 59 //把每个数据加5，然后对10取得余数 60 for(int x = 0; x < index; x++) { 61 arr[x] += 5; 62 arr[x] %= 10; 63 } 64 65 //把第一位和最后一位交换 66 int temp = arr[0]; 67 arr[0] = arr[index - 1]; 68 arr[index - 1] = temp; 69 70 //把数组的元素拼接成一个字符串返回 71 //定义一个空内容字符串 72 String s = ""; 73 74 for(int x = 0; x < index; x++) { 75 s += arr[x]; 76 } 77 78 return s; 79 } 80 } =============================================================================我的GitHub地址： https://github.com/heizemingjun 我的博客园地址： http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址： http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名，谢谢！】
2018-02-08
优秀的个人博客,低调大师

java基础学习_基础语法(下)01_day05总结

========================================================================================================================================================== 涉及到的知识点有：1：方法(掌握) (1)方法的定义 (2)方法的格式 (3)如何写一个方法呢？两个明确 (4)如何进行方法调用呢？ A:有明确返回值的方法调用的方式 B:没有明确返回值的方法调用的方式：(即用void类型修饰的方法调用) (5)方法的案例 (6)方法的注意事项 (7)方法的重载 (8)方法重载的案例2：数组(一维数组)(掌握) (1)数组的定义 (2)数组的特点 (3)数组的定义格式 (4)数组的初始化方式 A:动态初始化 B:静态初始化(常用) (5)Java语言的内存分配 (6)数组的内存图解 (7)数组操作时的两个常见小问题 (8)数组的常见操作 A:数组的遍历 方式1 方式2 B:数组的最值 最大值 最小值 C:数组的逆序(逆置) 方式1：//使用一个索引，需要考虑到变量的变化。 方式2：//使用两个索引，不用考虑变量变化。 D:数组的查表(根据键盘录入索引,查找对应星期) E:数组的元素查找(查找指定元素第一次在数组中出现的索引) ==========================================================================================================================================================1：方法(掌握) (1)方法的定义：就是完成特定功能的代码块。 注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。 (2)方法的格式： 修饰符 返回值类型 方法名(参数类型 参数名1, 参数类型 参数名2, 参数类型 参数名3...) { 方法体语句; ---------------------------------------------------- return 返回值; 参数列表 } --------------------------------------- 修饰符：目前就用 public static。后面再详细讲解其他修饰符。 返回值类型：就是功能结果的数据类型。 方法名：就是起了一个名字，符合命名规则即可，方便我们调用该方法。 参数类型：就是参数的数据类型。限定调用方法时传入参数的数据类型。 参数名：就是变量名，接收调用方法时传入的参数。 参数分类： 实际参数(实参)：实际参与运算的数据。 形式参数(形参)：方法上定义的，用于接收实际参数的变量。 方法体语句：就是完成功能的代码。 return：结束方法以及返回方法指定类型的值。 返回值：就是功能的结果，由return带给调用者。 (3)如何写一个方法呢？两个明确： a:返回值类型：明确功能结果的数据类型。 b:参数列表：明确参数的个数以及参数的数据类型。 (4)如何进行方法调用呢？ A:有明确返回值的方法调用的方式： a:单独调用，没有意义。 sum(x, y); b:输出调用，但是不够好，因为我不一定非要把结果输出，可能针对结果进行进一步操作。但是讲课一般我就用了。 System.out.println(sum(x, y)); c:赋值调用，推荐方式。 int z = sum(x, y); 如下图所示01： B:没有明确返回值的方法调用的方式：(即用void类型修饰的方法调用) a:只能单独调用。 (5)方法的案例： A:求和方案。 B:获取两个数中的较大值。(返回值是int类型，用三元改进。) C:比较两个数据是否相同。(返回值是boolean类型，用三元改进。) D:获取三个数中的最大值。(返回值是int类型，用if else嵌套，用三元改进。) E:输出m行n列的星形。(返回值是void类型。) F:键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表。 (6)方法的注意事项： A:方法不调用不执行。 B:方法与方法是平级关系，不能嵌套定义。 C:方法在定义的时候，参数是用逗号,隔开的 D:方法在调用的时候，不用在传递数据的类型。 E:如果方法有明确的返回值类型，就必须有return语句返回。 (7)方法的重载 在同一个类中，方法名相同，参数列表不同。与返回值无关。 参数列表不同： 参数的个数不同。 参数的对应的数据类型不同。 (8)方法重载的案例 不同的类型的多个同名方法的比较。----------------------------------------------------------------------------- 2：数组(一维数组)(掌握) (1)数组的定义：存储同一种数据类型的多个元素(变量)的容器(集合)。 (2)数组的特点：每一个元素都有编号，从0开始，最大编号是长度-1。 编号的专业叫法：索引(角标)。 数组既可以存储基本数据类型，也可以存储引用数据类型。 (3)数组的定义格式： A:数据类型[] 数组名; int[] a; //定义了一个int类型的数组a变量。 B:数据类型 数组名[]; int a[]; //定义了一个int类型的a数组变量。 --------------------------------------- 推荐是用A方式，A方式的可读性更强，B方法就忘了吧。在Java中均可。 B方式早期的时候确实有很多人这样用。不过，现在这样用的人越来越少了。 作为Java的粉丝C#(Java的模仿者)就不再支持第二种语法格式了。越来越多的语言可能会抛弃第二种格式。 但是看源码的时候要能看懂。 (4)数组的初始化方式： Java中的数组必须先初始化,然后才能使用。 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。 A:动态初始化 只指定数组长度，由系统分配初始值。(数组长度其实就是数组中元素的个数。) 举例： int[] arr = new int[3]; System.out.println(arr); //[I@6d06d69c 地址值，数组名其实就是该数组首元素的地址。 B:静态初始化(常用) 给初值，由系统决定数组长度。 举例： int[] arr = new int[]{ 1, 2, 3 }; 简化版：int[] arr = { 1, 2 ,3 }; 如下图所示06： (5)Java语言的内存分配： Java程序在运行时，需要在内存中的分配空间。 为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。 A:栈：存储局部变量。 B:堆：存储所有new出来的东西。 C:方法区(面向对象部分详细讲解) D:本地方法区(系统相关) E:寄存器(CPU使用) --------------------------------------- 注意： a:局部变量：在方法定义中或者方法声明上定义的变量。使用完毕，立即消失。 b:栈内存和堆内存的区别： 栈：数据使用完毕，就消失。 堆：每一个new出来的东西都有地址。 堆中的每一个变量都有默认值。 byte,short,int,long --> 0 float,double --> 0.0 char --> '\u0000' //因为Java语言采用的是Unicode编码。 boolean --> false 引用类型 --> null 在Java语言中，数据使用完毕后，就变成垃圾了，但并没有立即回收，会在垃圾回收器空闲的时候回收。 在C++语言中，有构造函数和析构函数，调用析构函数用来释放空间。 如下图所示02： (6)数组的内存图解: A:一个数组 B:二个数组 C:三个数组(两个栈变量指向同一个堆内存) 如下图所示03/04/05： (7)数组操作时的两个常见小问题： a：ArrayIndexOutOfBoundsException:数组索引越界异常。 原因：你访问了不存在的索引。 b：NullPointerException:空指针异常。 原因：数组已经不再指向堆内存了。而你还用数组名去访问元素。(即:数组引用没有指向实体，却在操作实体中的元素。) (8)数组的常见操作:--------------------------------------- A:数组的遍历 数组的一个属性：获取数值长度：数值名.length 方式1： public static void printArray(int[] arr) { for(int x = 0; x < arr.length; x++) { System.out.println(arr[x]); } } 方式2：通过字符串的拼接，让元素在一行上输出。 public static void printArray(int[] arr) { System.out.print("[ "); for(int x = 0; x < arr.length; x++) { if(x == arr.length - 1) { System.out.println(arr[x]+" ]"); }else { System.out.print(arr[x]+", "); } } }--------------------------------------- B:数组的最值 最大值： public static int getMax(int[] arr) { int max = arr[0]; for(int x = 1; x < arr.length; x++) { if(arr[x] > max) { max = arr[x]; } } return max; } 最小值： public static int getMin(int[] arr) { int min = arr[0]; for(int x = 1; x < arr.length; x++) { if(arr[x] < min) { min = arr[x]; } } return min; }--------------------------------------- C:数组的逆序(逆置) 方式1：//使用一个索引，需要考虑到变量的变化。 public static void reverse(int[] arr) { for(int x = 0; x < arr.length / 2; x++) { int temp = arr[x]; arr[x] = arr[arr.length - 1 - x]; arr[arr.length - 1 - x] = temp; } } 方式2：//使用两个索引，不用考虑变量变化。 public static void reverse(int[] arr) { for(int start = 0, end = arr.length - 1; start <= end; start++, end--) { int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; } }--------------------------------------- D:数组的查表(根据键盘录入索引,查找对应星期) public static String getString(String[] strArray, int index) { return strArray[index]; } E:数组的元素查找(查找指定元素第一次在数组中出现的索引) 方式1： public static int getIndex(int[] arr, int value) { for(int x = 0; x < arr.length; x++) { if(arr[x] == value) { return x; } } return -1; //找不到的时候对应的返回的值。或者是for循环的判断条件语句为false时候对应的方茴的值。 } 特别注意：只要是判断条件语句，就有可能是false，所以要细心！！！ 方式2： public static int getIndex(int[] arr, int value) { int index = -1; for(int x = 0; x < arr.length; x++) { if(arr[x] == value) { index = x; break; } } return index; }=============================================================================我的GitHub地址： https://github.com/heizemingjun 我的博客园地址： http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址： http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名，谢谢！】
2018-02-07
优秀的个人博客,低调大师

java基础学习_基础语法(上)02_day03总结

========================================================================================================================================================== 涉及到的知识点有：0：基本概念概述 1：运算 2：运算符 3：操作数 4：表达式1：运算符(掌握) (1)算术运算符(掌握) (2)赋值运算符(掌握) (3)比较(关系)运算符(掌握) (4)逻辑运算符(掌握) (5)位运算符(了解) (6)三元(三目/条件)运算符(掌握)2：键盘录入(掌握)3：流程控制语句4：if语句(掌握) (1)三种格式： (2)注意事项： (3)案例： (4)三元运算符和if语句第二种格式的关系： ==========================================================================================================================================================0：基本概念概述 1：运算 对常量和变量进行操作的过程称为运算。 2：运算符 对常量和变量进行操作的符号称为运算符。 3：操作数 参与运算的数据称为操作数 4：表达式 用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。 不同运算符连接的式子体现的是不同类型的表达式。 举例： int a = 3 + 4; 这是做了一个加法运算。 +就是运算符，且是算术运算符，我们还有其他很多的运算符。 3，4就是参与运算的操作数据。 3 + 4整体其实就是一个算数表达式。-----------------------------------------------------------------------------1：运算符(掌握) (1)算术运算符(掌握) A:+, -, *, /, %, ++, -- B:+的用法： a:加法； b:正号； c:字符串连接(拼接)符。 例如：System.out.println("x="+x+",y="+y);如下如图所示00： C:/和%的区别： 数据做除法操作的时候，/取得是商，%取得是余数。如下图所示01： D:++和--的用法： a:他们的作用是：对变量进行自增1或者自减1。 b:使用： **单独使用时： 放在操作数据的前面和后面效果是一样。 即：a++或者++a效果一样。 **参与操作使用时： 放在操作数的前面时：先自增1或者自减1，再参与操作。 int a = 10; int b = ++a; //a = 11; b = 11; 放在操作数的后面时：先参与操作，再自增1或者自减1。 int a = 10; int b = a++; //b = 10; a = 11;如下图所示02/03： --------------------------------------- (2)赋值运算符(掌握) A: 基本的赋值运算符：= 把=右边的数据赋值给左边。 扩展的赋值运算符：+=, -=, *=, /=, %=, 等等。 += 把左边和右边数据做加法后，然后将结果赋值给左边。 B:=叫做赋值运算符，也是最基本的赋值运算符。 int x = 10; //把10赋值给int类型的变量x。 C:扩展的赋值运算符的特点： 扩展的赋值运算符隐含了自动强制转换。 即：s += 1; 不是等价于 s = s + 1; 而是等价于 s = (s的数据类型)(s + 1); 面试题： short s = 1; //编译有问题，报错，可能损失精度。 s = s + 1; //short类型参与运算的时候默认转换为int类型。而把int类型赋值给short类型会有问题。 short s = 1; //没有问题。 s += 1; //因为+=隐含了自动强制转换。 请问上面的代码哪个有问题?--------------------------------------- (3)比较(关系)运算符(掌握) A:==, !=, >, >=, <, <=, instanceof(后面讲) B:无论运算符两端是简单还是复杂最终结果是boolean类型。 C:千万不要把==写成了=了。 D:>=, <=只要有一个满足即可，即：不管是大于，还是等于；或者不管是小于，还是等于。如下图所示04： --------------------------------------- (4)逻辑运算符(掌握) A: &, |, ^, !, &&, ||如下图所示05： B:逻辑运算符用于连接boolean类型的表达式，在java中不可以写成3<x<6，而是应该写成x>3&x<6。 表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。 例如： 算术表达式：a + b 比较表达式：a == b C:结论： 逻辑与&:有false则false。 逻辑或|:有true则true。 逻辑异或^:相同则false，不同则true。 举例情侣关系：男男为false，女女为false，男女为true，女男为true。 逻辑非!:非true则false，非false则true。 偶数个叹号!不改变布尔类型，奇数个叹号!改变类型。 逻辑双与&&:最终的结果和&是一样的，只不过有短路效果。只要左边是false，右边就不执行。 逻辑双或||:最终的结果和|是一样的，只不过有短路效果。只要左边是true，右边就不执行。 所以双与(双或)的效率更高！！！ 小结：在开发中常用的逻辑运算符为：&&， ||， ! 。--------------------------------------- (5)位运算符(了解) 因为我们一般是做十进制的运算的，而位运算是做的二进制的运算，所以我们一般不需要掌握，但是需要听懂！ 因为在底层源码中看大量看到位运算，因为我们的所有的操作在计算机底层都会变成为位运算。可以提高程序的效率。如下如所示06： 要做位运算，首先要把数据转换为二进制。而且还得是补码。如下图所示07： A:^异或位运算符的特殊用法： 一个数据针对另一个数据位异或两次，该数据本身不变。应用：可以对数据做一个简单的加密。如下图所示08： B:面试题： 以后讲课过程中，若没有明确说明数据类型的话，一般默认int类型。 a:请实现两个int变量的交换。int a = 10; int b = 20; 法一：采用第三方变量(开发中用)。 int c = a; a = b; b = c; 法二：用位异或运算符(面试中用)。简记为：等号左边a,b,a 等号右边a^b a = a ^ b; b = a ^ b; //a ^ b ^ b = a = b a = a ^ b; //a ^ b ^ a = b = a 法三：用变量相加的方法。 a = a + b; b = a - b; //a + b - b = a = b a = a - b; //a + b - a = b = a 法四：一句话搞定。 b = (a + b) - (a = b); //b = a + b - b = a b:请用最有效率的方式计算出2乘以8的结果 2<<3如下图所示09/10： --------------------------------------- (6)三元(三目/条件)运算符(掌握) 单目运算符：~3 双目运算符：3 + 4 A:三目运算符格式： 比较表达式? 表达式1 : 表达式2; B:执行流程： 首先计算比较表达式的值，看是true还是false。 如果是true，表达式1就是结果。 如果是false，表达式2就是结果。 C:案例： a:获取两个数据中的最大值。 int max = ((x > y)? x : y); b:获取三个数据中的最大值。 法一： int tmpe = ((a > b)? a : b); int max = ((tmpe > c)? tmpe : c); 法二： int max = (a > b)? ((a > c)? a : c) : ((b > c)? b : c); //三目运算符的嵌套使用。 c:比较两个数据是否相等。 法一： boolean flag = ((a == b)? true : flase); //这样写太啰嗦了。 法二： boolean flag = (a == b); 如下图所示11： ----------------------------------------------------------------------------- 2：键盘录入(掌握) (1)实际开发中，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。 (2)如何实现键盘录入数据呢？目前就记住： A:导包： import java.util.Scanner; 位置：在class定义的上边。 B:创建键盘录入对象： Scanner sc = new Scanner(System.in); C:通过对象获取数据： int x = sc.nextInt(); (3)把三元运算符的案例加入键盘录入改进。-----------------------------------------------------------------------------3：流程控制语句 (1)顺序结构：从上往下，依次执行。 (2)选择结构：按照不同的选择，执行不同的代码。 (3)循环结构：做一些重复的代码。 选择结构也称为分支结构。Java语言提供了两种选择结构语句。 1）if语句。 2）switch语句。-----------------------------------------------------------------------------4：if语句(掌握) (1)三种格式： A:格式1： if(比较/关系表达式) { 语句体; } 执行流程： 判断比较表达式的值，看是true还是false。 如果是true，就执行语句体。 如果是false，就不执行语句体。--------------------------------------- B:格式2 if(比较表达式) { 语句体1; }else { 语句体2; } 执行流程： 判断比较表达式的值，看是true还是false。 如果是true，就执行语句体1。 如果是false，就执行语句体2。 if语句的第二种格式与三元运算符的区别如下图所示12： --------------------------------------- C:格式3 if(比较表达式1) { 语句体1; }else if(比较表达式2) { 语句体2; }else if(比较表达式3) { 语句体3； }... ... }else if(比较表达式n) { 语句体n; } else { 语句体n+1; } 执行流程： 判断比较表达式1的值，看是true还是false。 如果是true，就执行语句体1。 如果是false，就继续判断比较表达式2的值，看是true还是false。 如果是true，就执行语句体2。 如果是false，就继续判断比较表达式3的值，看是true还是false。 ... ... 如果都不满足，就执行语句体n+1。--------------------------------------- (2)注意事项： A:比较表达式无论是简单还是复杂，结果必须是boolean类型。 B:if语句控制的语句体如果是一条语句，是可以省略大括号的；如果是多条语句，则不能省略。 建议：永远不要省略。 C:一般来说：有左大括号就没有分号，有分号就没有左大括号。如下图所示13： D:else后面如果没有if，是不会出现比较表达式的。 E:三种格式的if语句其实都是一个语句，只要有一个语句体执行，其他的语句体就不再执行。--------------------------------------- (3)案例： A:比较两个数是否相等。 B:获取两个数中的最大值。 C:获取三个数中的最大值(if语句的嵌套)。 D:根据成绩输出对应的等级。 E:根据月份，输出对应的季节。 F:根据x计算对应y的值并输出。如下图所示14： (4)三元运算符和if语句第二种格式的关系： 所有的三元运算符能够实现的，if语句的第二种格式都能实现。 反之不成立。 如果if语句第二种格式控制的语句体是输出语句，就不可以。 因为三元运算符是一个运算符，必须要求有一个结果返回。不能是一个输出语句。=============================================================================我的GitHub地址： https://github.com/heizemingjun 我的博客园地址： http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址： http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名，谢谢！】
2018-02-05
优秀的个人博客,低调大师

java基础学习_基础语法(上)01_day02总结

============================================================================= ============================================================================= 涉及到的知识点有： 1：关键字(掌握) 2：标识符(掌握) 3：注释(掌握) 4：常量(掌握) 5：进制转换(了解) 6：变量(掌握) 7：数据类型(掌握) 8：数据类型转换(掌握) ==========================================================================================================================================================1：关键字(掌握) (1)被Java语言赋予特定含义的单词。 (2)特点： 组成关键字的字母全部小写。 (3)注意事项： A:goto和const作为保留字存在，目前并不使用。注意：保留字在jdk的新版本中可能会提升为关键字。 B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记。 示例代码如下： 1 /* 2 关键字：被java语言赋予特定含义的单词。 3 4 特点：组成关键字单词的字母全部小写。 5 6 注意： 7 A:goto和const是保留字，目前并不使用。注意：保留字在jdk的新版本中可能会提升为关键字。 8 B:类似于UE、Notepad++这样的高级记事本，针对关键字都有特殊的颜色标记。 9 */ 10 class KeyWordDemo { 11 public static void main(String[] args) { 12 System.out.println("HelloWorld"); 13 } 14 } java中用到的关键字如下图所示：（50个左右） -----------------------------------------------------------------------------2：标识符(掌握) (1)就是给类、接口、方法、变量等起名字的字符序列。 (2)组成规则： A:可由英文大小写字母组成； B:可由数字组成； C:可由$和_组成； D:可由中文组成，但是不建议用中文！ (3)注意事项： A:不能以数字开头； B:不能是java中的关键字； C:java语言严格区分大小写。 (4)开发的常见的命名规则(见名知意) A:包的命名(全部小写)，其实就是文件夹，用于把相同的类名进行区分。 单级包：小写。 举例：liuyi com 多级包：小写，用.隔开。 举例：cn.itcast com.baidu (习惯是域名反写) B:类或者接口的命名 一个单词：单词的首字母大写。 举例：Student,Demo 多个单词：每个单词首字母大写。 举例：HelloWorld,StudentName C:方法或者变量的命名 一个单词：单词的首字母小写。 举例：name,main 多个单词：从第二个单词开始，每个单词首字母大写。 举例：studentAge,showAllNames() D:常量的命名 全部大写 一个单词：大写 举例：PI 多个单词：大写，并用_隔开。 举例：STUDENT_MAX_AGE-----------------------------------------------------------------------------3：注释(掌握) (1)就是对程序进行解释说明的文字，不会被JVM解释执行。 (2)分类： A:单行注释：//注释文字 单行注释可以嵌套使用。 B:多行注释：/*注释文字*/ 多行注释不可以嵌套使用。 C:文档注释(后面讲)：/**注释文字.*/ 被javadoc工具解析生成一个说明书，面向对象部分讲解。 (3)把HelloWorld案例写了一个带注释的版本。 后面我们要写一个程序的过程。 需求：写一个程序，在控制台输出HelloWorld。 分析： 1:写一个java程序，首先定义类。 2:程序要想能够被jvm调用，必须定义main方法。 3:程序要想有输出结果，必须用输出语句。 实现： 1:定义类用的是class关键字，后面跟的是类名。 2:main方法的基本格式。 3:输出语句的基本格式。 代码体现： (4)注释的作用： A:解释说明程序，提高了代码的阅读性。 B:可以帮助我们调试程序。 后面我们会讲解一个更高端的一个调试工具。-----------------------------------------------------------------------------4:常量(掌握) (1)在程序执行的过程中，其值不发生改变的量。 (2)Java中常量的分类： A:字面值常量 例如："hello"、10、true B:自定义常量(后面讲) 例如：final int x = 10; (3)字面值常量 A:字符串常量 "hello" B:整数常量 12,23 C:小数常量 12.345 D:字符常量 'a','A','0' E:布尔常量 true、false F:空常量 null(后面讲)(闹) 代表什么都没有 注意：空常量null不可以直接用于打印输出。如下图所示： (4)在Java中针对整数常量提供了四种表现形式 A:二进制 由0，1组成。以0b开头。 B:八进制 由0，1,...,7组成。以0开头。 C:十进制 由0，1,...,9组成。整数默认是十进制。 D:十六进制 由0，1,...,9,a,b,c,d,e,f(大小写均可)组成。以0x开头。如下图所示： -----------------------------------------------------------------------------5：进制转换(了解) 如下图所示： (1)其他进制转换到十进制 系数：就是每一个位上的数值。 基数：x进制的基数就是x。 权：对每一个位上的数据，从右往左，并且从0开始编号，对应的编号就是该数据的权。 结果：系数*基数^权次幂之和。如下图所示： (2)十进制转换到其他进制 方法：除基取余，直到商为0，余数反转。如下图所示： (3)进制转换的快速转换法 A:十进制和二进制间的转换 8421码。8421码是BCD代码中最常用的一种。 B:二进制到八进制，十六进制的转换如下图所示： (4)原码、反码、补码如下图所示： (5)8421码： 8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。 在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。 例如： 1 1 1 1 1 1 1 1 128 64 32 16 8 4 2 1-----------------------------------------------------------------------------6：变量(掌握) (1)在程序的执行过程中，其值在某个范围内可以发生改变的量。 (2)变量的定义格式： A:数据类型 变量名 = 初始化值; B:数据类型 变量名; 变量名 = 初始化值; (3)从本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域； 因此，每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容），才能使用。 (4)为什么要定义变量呢？ 答：用来不断的存放同一类型的常量，并可以重复使用。 如下图所示： --------------------------------------- 使用变量的时候要注意的问题： A:作用域 变量定义在哪一级大括号中，那个大括号的范围就是这个变量的作用域。 相同的作用域中不能定义两个同名变量。 B:初始化值 没有初始化值的变量不能直接使用。 你只要在使用前给值就行，不一定非要在定义的时候就立即给值。 推荐建议：在定义的时候就给初值比较好。 C:在一行上建议只定义一个变量。 其实也可以定义多个变量，但是不建议，不好看。 -----------------------------------------------------------------------------7：数据类型(掌握) (1)Java语言是一种强类型语言，针对每种数据都提供了对应的数据类型。 (2)数据类型的分类： A:基本数据类型：4类8种。 B:引用数据类型：类、接口、数组、字符串、Lambda。 注意：字符串、Lambda这两种引用数据类型后面会学习到。 Lambda：兰亩达，希腊字母表中排序第十一位的字母。 大写Λ用于:粒子物理学上，Λ重子的符号。 小写λ用于:物理上的波长符号、放射学的衰变常数、线性代数中的特征值。西里尔字母的 Л 是由 Lambda 演变而成。 " λ "形似一个双手插兜儿，独自行走的人，表示"失意、无奈、孤独、低调、路过"之意的符号，最先流行于仙剑奇侠传。 如下图所示： (3)基本数据类型 A:整数类型 占用字节数(Byte) 默认是有符号的，数据范围是： byte 1 -2^8 ~ 2^15-1(-128 ~ 127) short 2 -2^15 ~ 2^15-1 int 4 -2^31 ~ 2^31-1 long 8 -2^63 ~ 2^63-1 B:浮点类型 float 4 -3.403e38 ~ 3.403e38 -3.4.3*10^38 ~3.4.3*10^38 double 8 -1.798e308 ~ 1.798e308 -1.798*10^308 ~ 1.798*10^308 C:字符类型 char 2 D:布尔类型 boolean 1--------------------------------------- 注意的地方： a:整数默认是int类型，小数默认是double。 b:声明长整数要加L或者l。 例如：int i1 = 600; //正确。 long l1 = 88888888888L; //必须加L或l否则会出错。一般用大写的L，因为小写的l像1。 c:声明单精度的浮点数要加F或者f。 例如：double d = 12345.6; //正确。 float f = 12.3f; //必须加f或F否则会出错。损失精度。 d:char类型数据用来表示通常意义上的“字符”，字符常量为用单引号括起来的单个字符。 例如：char ch1= 'a'; char ch2='中'; e:Java字符采用 Unicode 编码，每个字符占两个字节，因而可用十六进制编码形式表示。注：Unicode是全球语言统一编码。 f:boolean类型适于逻辑运算，一般用于程序流程控制。 boolean类型数据只允许取值 true 或 false ，不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。 g:与整数类型类似，Java浮点类型有固定的表数范围和字段长度，不受平台影响。 Java浮点类型常量有两种表示形式： 十进制数形式， 如: 3.14 314.0 科学记数法形式，如：3.14e2 3.14*10^2 h:Java各整数类型有固定的表数范围和字段长度，其不受具体操作系统的影响，以保证Java程序的可移植性。 i:所谓的有效数字：具体地说，是指在分析工作中实际能够测量到的数字。所谓能够测量到指的是包括最后一位估计的不确定的数字。 例如：对于一个近似数，从左边第一个不是0的数字起，到精确到的位数止，所有的数字都叫做这个数的有效数字。-----------------------------------------------------------------------------8：数据类型转换(掌握) (0)一般来说，我们在运算的时候，要求参与运算的数据类型必须一致。 (1)boolean类型不能转换为其他的数据类型。 (2)默认转换(从小到大)： A:byte,short,char --> int --> long -- float -- double。 B:byte,short,char相互之间不转换，他们参与运算时首先默认转换为int类型。如下图所示： (3)强制转换(从大到小)： A:可能会有精度的损失，一般不建议这样使用。 B:格式： 目标数据类型 变量名 = (目标数据类型)(被转换的数据); C:注意：不要随意的去使用强制转换，因为它隐含了精度损失的问题。 (4)思考题和面试题： 思考题：请问下面这个有没有问题？ double d = 12.345; float f = d; 答：有问题，可能损失精度。 A:下面两种方式有区别吗? float f1 = (float)12.345; float f2 = 12.345f; 答：f1其实是通过一个double类型转换过来的。 而f2本身就是一个float类型。 B:下面的程序有问题吗，如果有，在哪里呢? byte b1 = 3; byte b2 = 4; byte b3 = b1 + b2; //数据类型提升了，有问题，可能会损失精度。 byte b4 = 3 + 4; //没问题。常量，是先把结果计算出来，然后看是否在byte的范围内，如果在就不报错！ C:下面的操作结果是什么呢? byte b = (byte)130; //-126 我们要想知道结果是什么，就应该知道是如何进行计算的。 而我们又知道计算机中数据的运算都是补码进行的。 而要得到补码，首先要计算出数据的二进制。 a:获取130这个数据的二进制。首先130默认是有符号的int类型。 00000000 00000000 00000000 10000010 这是130的原码，也是反码，还是补码。 即在计算机内部存储的是补码： 00000000 00000000 00000000 10000010 b:做截取操作，截成byte类型的了。 10000010 这个结果是补码。 注意：电脑显示屏幕显示的是原码，且为十进制。 c:即已知补码求原码。 符号位 数值位 补码： 1 0000010 反码： 1 0000001 原码： 1 1111110 即得到输出是-126 D:字符参与运算 是查找ASCII里面的值 'a' --> 97 'A' --> 65 '0' --> 48 System.out.println('a'); //97 System.out.println('a' + 1); //98 E:字符串参与运算 首先运算是从左到右的。 字符串数据+其他数据做，结果是字符串类型。因为这里的+不是加法运算，而是是字符串的连接符(拼接符)。 其他数据+其他数据+字符串数据，先计算其他的值后再与字符串进行拼接。 System.out.println("hello"+'a'+1); //helloa1 System.out.println('a'+1+"hello"); //98hello System.out.println("5+5="+5+5); //5+5=55 System.out.println(5+5+"=5+5"); //10=5+5=============================================================================我的GitHub地址： https://github.com/heizemingjun 我的博客园地址： http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址： http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名，谢谢！】
2018-02-03

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2025-12-12 大小: 211.28KB 下载: 54次
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2025-12-21 大小: 189MB 下载: 2次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-01-03 大小: 1.42GB 下载: 2次
热门标签
SpringCloud Rocky Kubernetes OpenAi HarmonyOS6 Jdk25 SpringBoot4 Docker DeepSeek Redis Gemini3 Nacos3 Service Mesh

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册