首页 文章 精选 留言 我的

精选列表

搜索[techo day],共2891篇文章
优秀的个人博客,低调大师

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 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

java基础学习_基础语法(上)03_day04总结

========================================================================================================================================================== 涉及到的知识点有:1:switch语句(掌握)2:循环语句(掌握)3:循环结构(循环嵌套使用)4:控制跳转语句(掌握) ==========================================================================================================================================================1:switch语句(掌握) (1)格式: switch(表达式) { case 值1: 语句体1; break; case 值2: 语句体2; break; ...... ...... case 值n: 语句体n; break; default: 语句体n+1; break; //该break可以省略。 } 格式解释说明: switch:说明这是switch语句。 表达式:可以是byte,short,int,char。 JDK5以后表达式可以是枚举。 JDK7以后表达式可以是字符串。 case:后面的值就是要和表达式进行比较的值。 语句体部分:可以是一条或多条语句。 break:表示程序到这里中断,跳出switch语句了。 default:如果所有的情况都不匹配,就执行这里的,相当于if语句中的else。 (2)面试题: switch语句的表达式可以是byte吗?可以是long吗?可以是String吗? 可以,不可以,JDK7以后可以。 (3)执行流程: A:首先,计算表达式的值; B:其次,和每一个case的值进行匹配,如果有就执行对应的语句体,看到break就结束。 C:如果没有匹配,就执行default的语句体n+1。 (4)注意事项: A:case后面只能是常量,不能是变量;而且,多个case后面的值不能出现相同的。 B:default可以省略吗? 可以省略,但是不建议,因为它的作用是对不正确的情况给出提示。 特殊情况: case就可以把值固定(即:判断的值是固定的)。 例如:做单选题:A,B,C,D只有四个选项。 C:break可以省略吗? default后面的break可以省略。但是其余case后面的break不可以省略,否则出现的结果可能不是我们想要的。 即:会出现一个现象:case穿透。 最终我们建议都不要省略。 D:default一定要在最后吗? 不是,可以在任意位置。但是建议放在最后。因为default表示其它的情况。也即:default不是程序结束的标志。 E:switch语句的两种结束标志: a:遇到break就表示结束了。 b:如果一直没有遇到break,那就执行到程序的末尾才表示结束了。 特别注意一个情况:如下图所示01: (5)案例: A:键盘录入一个数字(1-7),输出对应的星期几。(表达式是byte,int,short的情况) B:单项选择题。(表达式是char的情况) //由于我们现在没有办法键盘录入得到一个'A','B','C','D' //此时需要强制转换为字符类型。 Scanner sc = new Scanner(System.in); int choiceNumber = sc.nextInt(); char choice = (char) choiceNumber; C:键盘录入一个字符串的问题。(表达式是字符串的情况) String s = sc.nextLine(); D:根据给定的月份,输出对应的季节。(可以使用case穿透简化代码) (6)if语句和switch语句各自的使用场景: A:if语句 针对boolean类型的判断。 针对一个范围的判断。 针对几个常量的判断。 B:switch语句 针对几个常量的判断。-----------------------------------------------------------------------------2:循环语句(掌握) (1)有三种:for循环,while循环,do...while循环。 注意:反复执行这个循环体时,需要在合适的时候把循环判断条件修改为false,从而结束循环。--------------------------------------- (2)for循环语句 A:格式: for(初始化语句;判断条件语句;控制条件语句) { 循环体语句; } 执行流程: a:执行初始化语句(只做一次); b:执行判断条件语句; 如果这里是true,就继续。 如果这里是false,循环就结束。 c:执行循环体语句; d:执行控制条件语句; e:回到b继续。 B:注意事项: a:判断条件语句无论是简单还是复杂,结果都是boolean类型。 b:循环体语句如果是一条,可以省略大括号,但是不建议省略。 c:一般来说:有分号就没有左大括号,有左大括号就没有分号。 C:案例: a:输出10次HelloWorld。 b:输出1-10的数据。 c:输出10-1的数据。 d:求1-10的和。(循环的求和思想)如下图所示02: e:求1-100的和,求1-100的偶数和,求1-100的奇数和。 f:求5的阶乘。 n! = n * (n - 1)! n! = n * (n - 1) *(n -2) * (n - 3) * ... * 3 * 2 * 1 g:在控制台打印水仙花数。 何为水仙花数?答:一个三位数,其各位数字的立方和等于该数本身。 ge: 153/1%10 = 3 shi: 153/10%10 = 5 bai: 153/100%10 = 1 qian: x/10000%10 wan: x/10000%10 ...... 小结: 如果想把某数的个位取出来,就用该数除以1取整后再对10取余; 如果想把某数的十位取出来,就用该数除以10取整后再对10取余; 如果想把某数的百位取出来,就用该数除以100取整后再对10取余; 其余位以此类推。 h:统计水仙花个数。 循环的统计思想。 i:改进版的回文数。 一个五位数:12621 个位 = 万位 十位 = 千位 个位 + 十位 + 千位 + 万位 = 百位 j:统计1-1000之间同时满足如下条件的数据有多少个。 x%3==2 x%5==3 x%7==2--------------------------------------- (3)while循环 A:基本格式: while(判断条件语句) { 循环体语句; } --------------------------------------- 扩展格式: 初始化语句; while(判断条件语句) { 循环体语句; 控制条件语句; } --------------------------------------- for(初始化语句;判断条件语句;控制条件语句) { 循环体语句; } --------------------------------------- 通过查看这个格式,我们就知道while循环可以和for循环等价转换。 B:while的练习: 把for语句的练习用while改进。 C:for和while的区别: a:使用上的区别: 如果想在循环结束后,继续使用控制条件语句所控制的那个变量,用while循环,否则用for循环。不知道的时候用for循环。 因为变量要及早的从内存中消失,可以提高内存的使用效率。 b:理解上的区别: for适合于一个范围内的判断。 while适合次数不明确的判断。 举例:吃葡萄。 D:案例: a:珠穆朗玛峰问题。(不知道次数用while) b:小芳存钱问题(break以后才能做)。--------------------------------------- (4)do...while循环 A:基本格式: do { 循环体语句; }while(判断条件语句); --------------------------------------- 扩展格式: 初始化语句; do { 循环体语句; 控制条件语句; }while(判断条件语句); --------------------------------------- for(初始化语句;判断条件语句;控制条件语句) { 循环体语句; } --------------------------------------- 通过查看格式,我们就可以看出其实三种循环的格式可以是统一的。 B:三种循环的区别: a:do...while循环至少执行一次循环体。 b:for和while必须先判断条件是否是true,然后才能决定是否执行循环体。 c:我们一般优先考虑for,其次考虑while,最后考虑do...while。--------------------------------------- (5)循环使用的注意事项(死循环) A:一定要注意修改控制条件语句,否则容易出现死循环。 B:最简单的死循环格式: a:while(true){...} b:for(;;){...}-----------------------------------------------------------------------------3:循环结构(循环嵌套使用) 循环嵌套:循环语句的循环体本身就是一个循环语句。 (1)请输出一个4行5列的星星(*)图案. ***** ***** ***** ***** for (int x = 0; x < 4; x++) { //外循环控制行数。 for (int y = 0; y < 5; y++) { //内循环控制列数。 System.out.print("*"); } System.out.println(); } (2)请输出如下图形. * ** *** **** ***** for (int x = 0; x < 5; x++) { //外循环控制行数。 for (int y = 0; y <= x; y++) { //内循环控制列数。 System.out.print("*"); } System.out.println(); } (3)在控制台输出九九乘法表。 * ** *** **** ***** ****** ******* ******** ********* for (int x = 0; x < 9; x++) { //外循环控制行数。 for (int y = 0; y <= x; y++) { //内循环控制列数。 System.out.print("*"); } System.out.println(); } --------------------------------------- 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 ... ... ... ... ... 1*9=9 2*9=18 3*9=27 4*9=36 ... for (int x = 1; x <= 9; x++) { //外循环控制行数。 for (int y = 1; y <= x; y++) { //内循环控制列数。 System.out.print(y+"*"+x+"="+y*x+"\t"); } System.out.println(); } (4)注意事项: '\x' x表示任意,这种做法叫转移字符。 '\t' tab键的位置 '\r' 回车(回到旧行的开端) '\n' 换行(换到新行的开端)----------------------------------------------------------------------------- 4:控制跳转语句(掌握) (1)break:中断的意思 A:用在循环(loop)语句中加入了if判断的情况和switch语句中,离开此应用场景无意义。 B:作用: a:跳出单层循环。 b:跳出多层循环,需要与标签语句的配合。即给循环起个名字。但是呢,几乎不用,跳出多层循环。应用:break配合标签使用,可以通过内循环控制外循环。 格式:标签名:语句 例如: wc:for(int x = 0; x < 3; x++) { nc:for(int y = 0; y < 4; y++) { if(y == 2) { //break nc; break wc; } System.out.print("*"); } System.out.println(); }--------------------------------------- (2)continue:继续的意思 A:用在循环中,离开此应用场景无意义。 B:作用: break:跳出单层循环,循环结束,不在继续下去了。 continue:跳出一次单层循环,但循环没有结束,继续下一次循环。特别注意:在while循环的循环体中使用continue,可能使程序停不下来。 C:填空题 (1) for(int x = 1; x < 10; x++) { if(x == 3) { //break; //1 2 continue; //1 2 4 5 6 7 8 9 } System.out.println(x); } (2) for(int x = 1; x <= 10; x++) { if(x%3 == 0) { //在此处填写代码 } System.out.println(“Java基础班”); } 如何让控制台输出2次:Java基础班 break; 如何让控制台输出7次:Java基础班 continue; 如何让控制台输出13次:Java基础班 System.out.println(“Java基础班”);--------------------------------------- (3)return:返回的意思 return关键字不是为了跳转出循环体,更常用的功能是结束一个方法,也就是退出一个方法。 A:用于结束方法的,后面还会在继续讲解和使用。 B:一旦遇到return,程序就不会在继续往后执行。--------------------------------------- (4)用while语句和break结合使用:小芳存钱案例。 1 /* 2 需求:小芳的妈妈每天给她2.5元钱,她都会存起来,但是, 3 每当这一天是存钱的第5天或者5的倍数的话,她都会花去6元钱, 4 请问,经过多少天,小芳才可以存到100元钱。 5 分析: 6 A:小芳的妈妈每天给她2.5元钱。 7 double dayMoney = 2.5; 8 B:她都会存起来 9 double daySum = 0; 10 C:从第一天开始存储。 11 int dayCount = 1; 12 D:经过多少天,小芳才可以存到100元钱。 13 double result = 100; 14 E:这一天是存钱的第5天或者5的倍数的话,她都会花去6元钱, 15 说明要判断dayCount的值,如果对5整除就减去6元钱。 16 daySum -= 6; 17 由此还隐含了一个问题,就是要判断dayCount的值,如果不是5的倍数天的话,钱要累加。 18 daySum += dayMoney; 19 F:因为不知道是多少天,所以我用死循环,一旦超过100元我就退出循环。 20 */ 21 class WhileDemo { 22 public static void main(String[] args) { 23 //每天要存储的钱是2.5元 24 double dayMoney = 2.5; 25 26 //存钱的初始化值是0 27 double daySum = 0; 28 29 //从第一天开始存储 30 int dayCount = 1; 31 32 //最终存储不小于100就不存储了 33 int result = 100; 34 35 //因为不知道是多少天,所以我用死循环, 36 while(true) { 37 //累加钱 38 daySum += dayMoney; 39 40 //一旦超过100元我就退出循环。 41 if(daySum >= result) { 42 System.out.println("共花了"+dayCount+"天存储了100元"); 43 break; 44 } 45 46 if(dayCount%5 == 0) { 47 //花去6元钱 48 daySum -= 6; 49 System.out.println("第"+dayCount+"天花了6元钱"); 50 } 51 52 //天数变化 53 dayCount++; 54 } 55 } 56 } =============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

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 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

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 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 44)——重写属性

重写实例属性 我们可以在子类中重写从父类继承来的属性,属性有实例属性和静态属性之分,他们在具体实现也是不同的。 实例属性的重写一方面可以重写getter和setter访问器,另一方面可以重写属性观察者。 计算静态属性需要使用getter和setter访问器,而存储属性不需要。子类在继承父类后,也可以通过getter和setter访问器重写父类的存储属性和计算属性。 下面看一个示例: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 class Person{ varname:String //存储属性 varage:Int //存储属性 funcdescription()->String{ return "\(name)年龄是:\(age)" } init(name:String,age:Int){ self.name=name self.age=age } } class Student:Person{ varschool:String overridevarage:Int{ //重写属性前面要添加override关键字 get{ return super .age } set{ super .age=newValue< 8 ? 8 :newValue } } convenienceinit(){ self.init(name: "Tony" ,age: 18 ,school: "清华大学" ) } init(name:String,age:Int,school:String){ self.school=school super .init(name:name,age:age) } } letstudent1=Student() print( "学生年龄:\(student1.age)" ) student1.age= 6 print( "学生年龄:\(student1.age)" ) 从属性重写可见,子类本身并不存储数据,数据是存储在父类的存储属性中的。 以上示例是重写属性getter和setter访问器,我们还可以重写属性观察者,代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 class Person{ varname:String varage:Int funcdescription()->String{ return "\(name)年龄是:\(age)" } init(name:String,age:Int){ self.name=name self.age=age } } class Student:Person{ varschool:String overridevarage:Int{ //重写了age属性观察者 willSet{ //如果只关注修改之前的调用,可以只重写willSet观察者 print( "学生年龄新值:\(newValue)" ) } didSet{ //如果只关注修改之后的调用,可以只重写didSet观察者 print( "学生年龄旧值:\(oldValue)" ) } } convenienceinit(){ self.init(name: "Tony" ,age: 18 ,school: "清华大学" ) } init(name:String,age:Int,school:String){ self.school=school super .init(name:name,age:age) } } letstudent1=Student() print( "学生年龄:\(student1.age)" ) Student1.age= 6 print( "学生年龄:\(student1.age)" ) 代码Student1.age = 6修改了age属性,修改前后的输出结果如下: 学生年龄新值:6 学生年龄旧值:18 重写静态属性 在类中静态属性定义使用class或static关键字,但是使用哪一个要看子类中是否重写该属性。class修饰的属性可以被重写,static关键字就不能被重写。 示例代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 class Account{ varamount:Double= 0.0 //账户金额 varowner:String= "" //账户名 varinterestRate:Double= 0.0668 //利率 //class不能换成static class varstaticProp:Double{ //静态属性staticProp return 0.0668 *1_000_000 } varinstanceProp:Double{ return self.interestRate*self.amount } } class TermAccount:Account{ //class换成static override class varstaticProp:Double{ //重写静态属性staticProp return 0.0700 *1_000_000 } } //访问静态属性 print(Account.staticProp) print(TermAccount.staticProp) 由于要被重写所以代码class var staticProp: Double中的class不能换成static。代码overrideclass var staticProp: Double中的静态属性staticProp可以使用class或static,除非在TermAccount的子类中重写属性staticProp。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1747501,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 59)——代码排版

代码排版包括:空行、空格、断行和缩进等内容。代码排版内容比较多工作量很多,但是非常重要。 空行 空行将逻辑相关的代码段分隔开,以提高可读性。下列情况应该总是添加空行: 类型声明之前。 import语句前后。 两个方法或函数之间。 块注释或单行注释之前。 方法或函数内的两个逻辑段之间,用以提高可读性。 一个源文件的两个片段之间。 空格 在代码中有些位置是需要有空格的,这个工作量也是很大的。下列是使用空格的规范: 1.赋值符号“=”前后有一个空格。var或let与标识符之间有一个空格。所有的二元运算符,应该使用空格将之与操作数分开。一元操作符和操作数之间不因该加空格,如:++、--等。示例如下。 1 2 3 vara= 10 varc= 10 a+=c+d 2.小左括号“(”之后,小右括号“)”之前不要有空格。示例如下。 1 a=(a+b)/(c*d) 3.大左括号“{”之前有一个空格。示例如下。 1 2 3 while a==d{ n++ } 4.在方法或函数参数之前间有一个空格,参数冒号与数据类型之间有一个空格。 推荐使用: 1 2 3 4 functableView(tableView:UITableView,didSelectRowAtIndexPathindexPath:NSIndexPath){ ... } 不推荐使用: 1 2 3 functableView(tableView:UITableView,didSelectRowAtIndexPathindexPath:NSIndexPath){ ... } 断行 一行代码的长度尽量避免超过80个字符,为了便于查看是否一行代码超出80个字符,很多IDE开发工具都可以在编辑窗口设置显示80行竖线。在Xcode中设置过程是打开菜单Xcode→Preferences,选择Text Editing标签,选中Show→Page guideat column。 由于有的代码比较长需要断行,可以依据如下一般规范断开: 在一个逗号后面断开。 在一个操作符前面断开,要选择较高级别运算符断开,而非较低级别运算符断开。 新的一行应该与上一行缩进两个级别(8个空格) 缩进 4个空格常被作为缩进排版的一个单位,在开发时候使用制表符进行缩进,虽然默认情况下一个制表符等于8个空格,但是在不同的IDE工具中可能设置的一个制表符与空格对应个数会有所不同。在Xcode中默认是一个制表符对应4个空格,我们可以在Xcode中打开菜单Xcode→Preferences,选择Text Editing→Indentation标签,可以在Tab width中进行设置。 缩进可以依据如下一般规范: 在函数、方法、闭包、控制语句、计算属性等包含大括号“{}”代码块中,代码块中的内容与首行缩进一个级(4个空格)。 如果是if语句中条件表达式的断行,那么新的一行应该与上一行缩进两个级别(8个空格),再往后的断行要与第一次的断行对齐。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1748346,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 27)——可选类型

可选类型: 我们先看看如下代码: 1 2 3 4 varn1:Int= 10 n1=nil //编译错误 letstr:String=nil //编译错误 Int和String类型不能接受nil的,但程序运行过程中有时被复制给nil是在所难免的,Swift为每一种数据类型提供一种可选类型(optional),即在某个数据类型后面加上问号(?)或感叹号(!),修改前文示例代码: 1 2 3 4 varn1:Int?= 10 n1=nil letstr:String!=nil Int?和String!都是原有类型Int和String可选类型,它们可以接受nil。 可选类型值拆包 在可选类型的问号(?)或感叹号(!)究竟有什么区别呢?这与可选类型的“拆包”(unwrapping)有关,拆包是将可选类型变成普通类型,如果我们直接打印非空的可选类型值,代码如下: 1 2 varn1:Int?= 10 print(n1) 输出的结果是Optional(10),而非10。所以试图计算表达式n1+ 100会发生编译错误,代码如下: 1 2 varn1:Int?= 10 print(n1+ 100 ) //发生编译错误 需要对可选类型值进行“拆包”是必要地。 “拆包”分为显示拆包和隐性拆包。 使用问号(?)声明的可选类型,在拆包时需要使用感叹号(!),这种拆包方式称为“显式拆包”; 使用感叹号(!)声明的可选类型,在拆包时可以不使用感叹号(!),这种表示方式称为“隐式拆包”。 看看下面代码: 1 2 3 4 5 varn1:Int?= 10 print(n1!+ 100 ) //显式拆包 varn2:Int!= 100 print(n2+ 200 ) //隐式拆包 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746587,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 26)——可选链

在Swift程序表达式中会看到问号(?)和感叹号(!),它们代表什么含义呢?这些符号都与可选类型和可选链相关,下面来看看可选链。 可选链: 类图: 它们之间是典型的关联关系类图。这些类一般都是实体类,实体类是系统中的人、事、物。Employee通过dept属性与Department关联,Department通过comp属性与Company关联。 下面看示例代码: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Employee{ varno:Int= 0 varname:String= "Tony" varjob:String? varsalary:Double= 0 vardept:Department=Department() } class Department{ varno:Int= 10 varname:String= "SALES" varcomp:Company=Company() } class Company{ varno:Int= 1000 varname:String= "EOrient" } letemp=Employee() //Employee实例 print(emp.dept.comp.name) // emp.dept.comp.name可以引用到Company实例,形成一个引用的链条,但是这个“链条”任何一个环节“断裂”都无法引用到最后的目标(Company实例)。 给定一个Employee实例,一定会有一个Department与其关联。但现实是一个新入职员工未必有部门,这种关联关系有可能有值,也有可能没有值,我们需要使用可选类型(Department?)声明dept属性。 修改代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Employee{ varno:Int= 0 varname:String= "Tony" varjob:String? varsalary:Double= 0 vardept:Department? //=Department() } class Department{ varno:Int= 10 varname:String= "SALES" varcomp:Company? //=Company() } class Company{ varno:Int= 1000 varname:String= "EOrient" } letemp=Employee() print(emp.dept!.comp!.name) //显示拆包 print(emp.dept?.comp?.name) //可选链 其中可选类型的引用,可以使用感叹号(!)进行显示拆包,代码修改如下: 1 print(emp.dept!.comp!.name) 但是显示拆包有一个弊端,如果可选链中某个环节为nil,将会导致代码运行时错误。我们可以采用更加“温柔”的引用方式,使用问号(?)来代替原来感叹号(!)的位置,如下所示: 1 print(emp.dept?.comp?.name) 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746584,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 16)——字典集合

Swift字典表示一种非常复杂的集合,允许按照某个键来访问元素。字典是由两部分集合构成的,一个是键(key)集合,一个是值(value)集合。键集合是不能有重复元素的,而值集合是可以重复的,键和值是成对出现的。 字典声明与初始化 Swift字典类型是Dictionary,也是一个泛型集合。 在声明一个Dictionary类型的时候可以使用下面的语句之一。 1 2 varstudentDictionary1:Dictionary<Int,String> varstudentDictionary2:[Int:String] 声明的字典需要进行初始化才能使用,字典类型往往是在声明的同时进行初始化的。示例代码如下: 1 2 3 4 5 varstudentDictionary1:Dictionary<Int,String> =[ 102 : "张三" , 105 : "李四" , 109 : "王五" ] varstudentDictionary2=[ 102 : "张三" , 105 : "李四" , 109 : "王五" ] letstudentDictionary3=[ 102 : "张三" , 105 : "李四" , 109 : "王五" ] 字典遍历 字典遍历过程可以只遍历值的集合,也可以只遍历键的集合,也可以同时遍历。这些遍历过程都是通过for-in循环实现的。 下面是遍历字典的示例代码: 1

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 31)——存储属性

Swift中的属性分为存储属性和计算属性,存储属性就是Objective-C中的数据成员,计算属性不存储数据,但可以通过计算其他属性返回数据。 存储属性可以存储数据,分为常量属性(用关键字let定义)和变量属性(用关键字var定义)。 存储属性概念: 我们在前面曾用到过属性,Employee类和Department结构体。它们的类图如下,Employee的部门属性dept与Department之间进行了关联。 我们可以在定义存储属性时指定默认值,示例代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Employee{ letno:Int= 0 varname:String= "" varjob:String? varsalary:Double= 0 vardept:Department? } structDepartment{ letno:Int= 0 varname:String= "" } letemp=Employee() emp.no= 100 //编译错误:修改常量属性,程序会发生编译错误 letdept=Department() dept.name= "SALES" //编译错误:dept是值类型,值类型不能修改,即便它的属性name是变量属性,也不能修改 letemp1=Employee() emp1.name= "Tony" 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746594,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 45)——重写方法

重写实例方法 在子类中重写从父类继承来的实例方法和静态方法。先介绍实例方法的重写。 下面看一个示例: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 class Person{ varname:String varage:Int funcdescription()->String{ //实例方法 return "\(name)年龄是:\(age)" } class funcprintClass()->(){ //静态方法 print( "Person打印..." ) } init(name:String,age:Int){ self.name=name self.age=age } } class Student:Person{ varschool:String convenienceinit(){ self.init(name: "Tony" ,age: 18 ,school: "清华大学" ) } init(name:String,age:Int,school:String){ self.school=school super .init(name:name,age:age) } overridefuncdescription()->String{ //重写实例方法description,重写的方法前面要添加关键字override print( "父类打印\(super.description())" ) return "\(name)年龄是:\(age),所在学校:\(school)。" } override class funcprintClass()->(){ //重写静态方法printClass print( "Student打印..." ) } } letstudent1=student() print( "学生1:\(student1.description())" ) //调用了description方法 Person.printClass() Student.printClass() 使用super.description()语句调用父类的description方法,其中super指代父类实例。 重写静态方法printClass,在静态方法中不能访问实例属性。 调用了description方法。由于在子类中重写了该方法,所以调用的是子类中的description方法。输出结果是: 父类打印Tony年龄是: 18 学生1:Tony年龄是: 18,所在学校:清华大学。 为了测试静态方法重写,调用Person.printClass()语言,它是调用父类的printClass静态方法,输出结果是: Person打印... 调用Student.printClass()语言,它是调用子类的printClass静态方法,输出结果是: Student打印... 重写静态方法 与类的静态属性定义类似,静态方法使用class或static关键字,但是使用哪一个要看子类中是否重写该方法。class修饰的静态方法可以被重写,static关键字就不能被重写。 示例代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Account{ varowner:String= "Tony" //账户名 //不能换成static class funcinterestBy(amount:Double)->Double{ //静态方法 return 0.08886 *amount } } class TermAccount:Account{ //定期账户 //可以换成static override class funcinterestBy(amount:Double)->Double{ //静态方法 return 0.09 *amount } } //调用静态方法 print(Account.interestBy(10_000. 00 )) print(TermAccount.interestBy(10_000. 00 )) 由于被重写所以代码class funcinterestBy(amount: Double) -> Double中的class不能换成static。静态方法interestBy可以使用class或static,除非在TermAccount的子类中重写方法interestBy。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1747504,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 46)——下标重写

下标是一种特殊属性。子类属性重写是重写属性的getter和setter访问器,对下标的重写也是重写下标的getter和setter访问器。 下面看一个示例: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 classDoubleDimensionalArray{ letrows:Int,columns:Int vargrid:[Int] init(rows:Int,columns:Int){ self.rows=rows self.columns=columns grid=Array(count:rows*columns,repeatedValue: 0 ) } subscript(row:Int,col:Int)->Int{ //定义下标 get{ return grid[(row*columns)+col] } set{ grid[(row*columns)+col]=newValue } } //定义下标 } class SquareMatrix:DoubleDimensionalArray{ overridesubscript(row:Int,col:Int)->Int{ //重写父类下标 get{ return super .grid[(row*columns)+col] } set{ super .grid[(row*columns)+col]=newValue*newValue } } } varary2=SquareMatrix(rows: 5 ,columns: 5 ) for vari= 0 ;i< 5 ;i++{ for varj= 0 ;j< 5 ;j++{ ary2[i,j]=i+j } } for vari= 0 ;i< 5 ;i++{ for varj= 0 ;j< 5 ;j++{ print( "\t\t\(ary2[i,j])" ) } print( "\n" ) } 其中super.grid[(row * columns) + col]语句中使用super调用父类的grid属性。 其中super.grid[(row * columns) + col] = newValue * newValue语句是给父类的grid属性赋值。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1747531,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 49)——扩展声明

声明扩展的语法格式如下: 1 2 3 extension类型名{ //添加新功能 } 声明扩展的关键字是extension,“类型名”是Swift中已有的类型,包括类、结构体和枚举,但是我们仍然可以扩展整型、浮点型、布尔型、字符串等基本数据类型,这是因为这些类型本质上也是结构体类型。打开Int的定义如下: 1 2 3 4 5 6 7 8 9 structInt:SignedInteger{ init() init(_value:Int) static funcconvertFromIntegerLiteral(value:Int)->Int typealiasArrayBoundType=Int funcgetArrayBoundValue()->Int static varmax:Int{get} static varmin:Int{get} } 从定义可见Int是结构体类型。不仅是Int类型,我们熟悉的整型、浮点型、布尔型、字符串等数据类型本质上都是结构体类型。 Swift中的扩展机制可以在原始类型中添加的新功能包括: 实例计算属性和类型计算属性 实例方法和类型方法 构造函数 下标 还有嵌套类型等内容也可以扩展,扩展还可以遵从协议。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1747536,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 36)——静态方法

静态方法与静态属性类似,Swift中定义了静态方法,也称为类型方法。静态方法的定义与静态属性类似,枚举和结构体的静态方法使用的关键字是static;类静态方法使用的关键字是class或static,如果使用static定义,则该方法不能在子类中被重写(override);如果使用class定义,则该方法可以被子类重写。 结构体静态方法 看一个结构体静态方法的示例,代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 structAccount{ varowner:String= "Tony" //声明实例属性账户名 static varinterestRate:Double= 0.0668 //声明静态属性利率 static funcinterestBy(amount:Double)->Double{ //定义静态方法 return interestRate*amount } funcmessageWith(amount:Double)->String{ //定义实例方法 letinterest=Account.interestBy(amount) return "\(self.owner)的利息是\(interest)" } } //调用静态方法 print(Account.interestBy(10_000. 00 )) varmyAccount=Account() //调用实例方法 print(myAccount.messageWith(10_000. 00 )) 枚举静态方法 看一个枚举静态方法的示例,代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 enum Account{ case 中国银行 case 中国工商银行 case 中国建设银行 case 中国农业银行 static varinterestRate:Double= 0.0668 //声明静态属性利率 static funcinterestBy(amount:Double)->Double{ //定义静态方法 return interestRate*amount } } //调用静态方法 print(Account.interestBy(10_000. 00 )) //调用静态方法 从示例可以看出,结构体和枚举的静态方法使用定义没有区别。 类静态方法 看一个类静态方法的示例,代码如下: 1 2 3 4 5 6 7 8 9 10 11 class Account{ varowner:String= "Tony" //账户名 //可以换成static class funcinterestBy(amount:Double)->Double{ //使用关键字class定义静态方法 return 0.08886 *amount } } //调用静态方法 print(Account.interestBy(10_000. 00 )) //调用静态方法 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746990,如需转载请自行联系原作者

优秀的个人博客,低调大师

Android Day08四大组件之服务Service

拓展: Android之Service与IntentService的比较 http://blog.csdn.net/smile3670/article/details/7702521 Java并发编程:volatile关键字解析 http://www.cnblogs.com/dolphin0520/p/3920373.html java中volatile关键字的含义 http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html 保证服务不被杀死: http://blog.csdn.net/mad1989/article/details/22492519 (提高优先级,服务死掉的时候发送广播,重启服务) 1.什么是服务 就把服务理解为在后台长期运行但是没有界面的Activity,因为Service与Activity有很多相似的地方。 1)启动一个activity或service都要通过Intent 2) 如果想打开一个activity/service,按是否返回数据,需要采用不同的方法。 ■服务的作用 让某些逻辑在后台(长期)执行。 服务可以结合广播接收者碰撞出各种效果(看你的想像力了!) 2.进程 Foreground process 前台进程 相当于Activity执行了onResume方法 用户正在操作页面 前台进程的优先级最高 Visible process 可视进程 相当于Activity执行了onPasue方法 用户依然能看的见屏幕 Service process 服务进程 相当于通过startservice方式开启了一个服务 在当前进程里面运行 Background process 后台进程 相当于Activity执行了onStop方法 用户看不见页面 但是注意Activity没有执行ondestroy方法 Empty process 空进程 后台没有任何组件运行 这个时候属于空进程 3.服务的创建和开启 ■服务的创建: 定义一个类继承Service,在清单文件里注册这个类,<service>标签。 ■服务的开启: 服务的开启属于Context里的方法,所以继承了Context的类Activity、Service或者是拥有Context对象的类 都可以开启一个服务(如广播接收者的onReceive方法里有Context对象,所以广播接收者也可以开启一个服务) 开启服务的方式有2种:startService和bindService。 不同的方式开启的服务,作用不同,服务的生命周期不同,服务需要复写的方法也不同,掌握 这两种开启服务的方式区别十分地重要。(********重点*********) 如果想要服务长期运行,就用startService方法;如果想调用服务里的方法,就用bindService 方法来开启服务。 不同方式开启服务的生命周期图: 1)startService方式开启服务 当用户第一次调用start-service方法 服务会执行onCreate、onStartCommand、onStart方法 当用户第二次调用start-service方法 服务只会走onStartCommand、onStart方法 服务一旦通过start-service方法开启后 服务就会在后台长期运行 直到用户手工停止或调用 stopService方法停止,或者服务调用自身的stopSelf()方法。如下图,手动关闭service: start开启服务代码 1 2 3 //启动服务 Intentintent= new Intent( this ,CallService. class ); startService(intent); 2)bindService方式开启服务 第一次点击按钮通过bindservice开启服务服务只会走onCreate和onbind方法 第二次点击按钮通过bindservice开启服务服务没有反应 不求同时生但求同时死只的是Activity和服务之间,Activity一挂掉,bind方式开启的服务也会 随之挂掉 服务只能解绑一次多次解绑会报异常 通过bindservice方式开启服务在设置页面找不到他可以理解成是一个隐形的服务 当服务的onbind方法返回null的时候onServiceConnected方法不执行 ▇bindservice方式调用服务方法里面的流程(**********重点**********) (1)定义一个服务 在清单文件里面配置 在服务里面定义一个方法 (2)Activity想调用服务里面的方法 (3)在服务的内部定义一个中间人对象(IBinder) 在这个实现类里面可以间接的调用到服务里面的 方法 (4)在onbind方法中把我们自己定义的这个中间人对象返回 (5)当Activity想调用服务里面方法的时候 先通过bindservice方法获取中间人对象 (6)通过我们获取的中间人对象就可以间接调用到服务里面的方法了 一般写在"中间人"对象(IBinder)里的方法,都是实现接口里的方法,再在方法里调用服 务里定义的方法。 ■绑定服务抽取接口 接口可以隐藏代码内部的细节 让程序员暴露只想暴露的方法 实现步骤 (1)定义一个接口 把服务里面想暴露方法都定义在接口里 (2)我们定义的这个中间人对象实现我们定义的这个接口 (3)还是通过bindservice方式获取我们中间人的对象 (4)还是通过中间人对象间接调用服务里面的方法 4.应用1_电话窃听器案例(startService开启服务方式) 需求:手机一接听电话就把通话进行录音,保存起来。 实现思路:电话窃听,肯定不希望用户看到,所以不需要界面,那么窃听录音的逻辑应写在服务里。服务有了, 需要被开启,为了显得应用更智能一些,就定义一个广播接收者来接收开机广播来开启服务了。 具体实现步骤: 1)定义电话窃听录音逻辑的服务类 创建服务类之后,按照好的编程习惯,立马在清单里配置service标签。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 public class CallService extends Service{ private MediaRecorderrecorder= null ; @Override public IBinderonBind(Intentarg0){ return null ; } @Override public void onCreate(){ super .onCreate(); //创建一个TelephonyManager对象 //注意要强转 TelephonyManagermanager=(TelephonyManager) this .getSystemService( this .TELEPHONY_SERVICE); //通过TelephonyManager来获取通话的状态?????????????????????/ manager.listen( new MyPoneListener(),PhoneStateListener.LISTEN_CALL_STATE); //注意常量是PhoneStateListener的常量。 } //定义一个类继承PhoneListener private class MyPoneListener extends PhoneStateListener{ //复写它的一个监听通话状态的方法 @Override public void onCallStateChanged( int state,StringincomingNumber){ //判断状态 /*int CALL_STATE_IDLE Devicecallstate:Noactivity. int CALL_STATE_OFFHOOK Devicecallstate:Off-hook. int CALL_STATE_RINGING Devicecallstate:Ringing.*/ //代表空闲状态 if (state==TelephonyManager.CALL_STATE_IDLE) { System.out.println( "结束录音" ); if (recorder!= null ) { recorder.stop(); recorder.reset(); //YoucanreusetheobjectbygoingbacktosetAudioSource()step recorder.release(); //Nowtheobjectcannotbereused } } //接听状态 else if (state==TelephonyManager.CALL_STATE_OFFHOOK) { System.out.println( "开始录音" ); if (recorder!= null ) { recorder.start(); //Recordingisnowstarted } } //响铃状态 if (state==TelephonyManager.CALL_STATE_RINGING) { System.out.println( "准备录音,创建录音机。" ); recorder= new MediaRecorder(); //设置录音录制的是双方的还是单方的。 recorder.setAudioSource(MediaRecorder.AudioSource.MIC); //设置录音的保存格式3GP recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); //设置录音的编码方式 recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); //设置录音的保存位置 recorder.setOutputFile( "/mnt/sdcard/record.mp3" ); try { //准备录音 recorder.prepare(); } catch (Exceptione){ e.printStackTrace(); } } } } } 2)定义广播接收者来启动服务 创建广播接收者之后,按照好的编程习惯,立马在清单里配置receiver标签,并配置好过滤器过滤开机广播。 1 2 3 4 5 6 7 8 9 10 public class BootReceiver extends BroadcastReceiver{ @Override public void onReceive(Contextcontext,Intentintent){ //当手机重启后开启服务 Intentintent1= new Intent(context,CallService. class ); context.startService(intent1); } } 3)添加权限 像什么配置组件,添加权限能提前完成的东西就提前完成。 1 2 3 4 5 6 7 8 9 10 11 <!--读取电话状态权限--> < uses-permission android:name = "android.permission.READ_PHONE_STATE" /> <!--录音权限--> < uses-permission android:name = "android.permission.RECORD_AUDIO" /> <!--SD卡读写权限--> < uses-permission android:name = "android.permission.WRITE_EXTERNAL_STORAGE" /> <!--开机启动监听--> < uses-permission android:name = "android.permission.RECEIVE_BOOT_COMPLETED" /> 5.应用2_百度音乐盒案例(start/bind混合开启服务方式) 需求:在activity里定义播放、暂停、继续3个功能按钮,效果如下图所示: 实现思路:一般音乐播放软件,在界面销毁之后,音乐还能继续在长期运行播放,所以音乐播放的逻辑应该写在服 务里,用startService方式开启服务;点击按钮还要调用服务里的方法,那么又要用bindService方 式开启服务。所以要以混合模式开启服务。 具体实现步骤: 1)服务相应接口定义 1 2 3 4 5 6 //定义一个接口来暴露想暴露的方法 public interface Iservice{ public abstract void callPlay(); public abstract void callPause(); public abstract void callRePlay(); } 2)服务定义 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 package com.itheima.baidumusic; import java.io.IOException; import android.app.Service; import android.content.Intent; import android.media.MediaPlayer; import android.net.Uri; import android.os.Binder; import android.os.IBinder; /** *播放音乐的Service逻辑写在Service里,通过中间人对象返回。 * *模板步骤:1.写一个类继承Binder,也就是IBinder(接口)的子类,并实现接口,暴露想暴露的方法。2.返回这个类的对象。 * *@authorLENOVO * */ public class PlayService extends Service{ private MediaPlayermusicPlayer= null ; @Override public IBinderonBind(Intentintent){ System.out.println( "onBind方法执行了。。。。。。" ); musicPlayer= new MediaPlayer(); try { musicPlayer.setDataSource( "/mnt/sdcard/luanhong.mp3" ); } catch (Exceptione){ e.printStackTrace(); } return new MyBinder(); } //定义播放音乐的方法 public void play(){ System.out.println( "播放音乐" ); try { musicPlayer.prepare(); } catch (Exceptione){ e.printStackTrace(); } musicPlayer.start(); } //定义暂停音乐的方法 public void pause(){ System.out.println( "暂停播放" ); musicPlayer.pause(); } //定义继续音乐的方法 public void rePlay(){ System.out.println( "继续播放" ); musicPlayer.start(); } //定义一个Binder的子类对象<中间人对象> public class MyBinder extends Binder implements Iservice{ @Override public void callPlay(){ play(); } @Override public void callPause(){ pause(); } @Override public void callRePlay(){ rePlay(); } } } 3)Activity里启动服务 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 public class MainActivity extends Activity{ //定义与服务的连接 private MyConnconn= null ; //自定义那个类才会具有独有的播放音乐的功能,直接声明那个类实现的接口,属于多态。 private IserviceserviceBinder= null ; @Override protected void onCreate(BundlesavedInstanceState){ super .onCreate(savedInstanceState); setContentView(R.layout.activity_main); //1.通过startService方法开启服务为了让音乐盒可以长期的运行,即按下回退键服务不会随之一起销毁。 Intentintent= new Intent( this ,PlayService. class ); startService(intent); conn= new MyConn(); //2.通过bindService方法开启服务为了调用服务里的方法 bindService(intent,conn,BIND_AUTO_CREATE); //3.在activity里的onDestroy方法里注销绑定服务。 } //定义一个类实现ServiceConnection接口 private class MyConn implements ServiceConnection{ @Override public void onServiceConnected(ComponentNamename,IBinderservice){ //注意要最终是要用Iservice的特有方法,所以要强转成Iservice. System.out.println( "绑定服务成功" ); serviceBinder=(Iservice)service; } @Override public void onServiceDisconnected(ComponentNamename){ System.out.println( "绑定服务失败" ); } } //实现点击按钮的方法 public void click(Viewv){ switch (v.getId()){ case R.id.bt_play: serviceBinder.callPlay(); break ; case R.id.bt_pause: serviceBinder.callPause(); break ; case R.id.bt_rePlay: serviceBinder.callRePlay(); break ; default : break ; } } //在activity里的onDestroy方法里注销绑定服务 @Override protected void onDestroy(){ //解除绑定服务 unbindService(conn); super .onDestroy(); } } 6.AIDL AndroidInterfaceDefinitionLanguageAndroid接口定义语言 本地服务:运行在自己应用(Android)里面的服务 远程服务:运行在其他应用(Android)里面的服务 作用: 想解决的问题就是进程间通信,也就是调用其它进程里的服务里的方法。 AIDL 实现的步骤 (1) 在一个应用里面定义一个服务 服务里面有一个方法 这个方法称为远程服务里面的方法 (2)在这个服务里面定义中间人对象 定义接口iservice.java 把想暴露的方法定义在接口里 (3)把iservice.java文件改成 aidl文件 注意aidl不支持public、abstract等修饰符 (4)系统会自动给我们生产一个iservice.java文件 stub extends IBinder imp iservie接口 (5)把我们定义的中间人对象直接继承Stub (6)我想在另外一个应用里面去调用这个服务里面的方法 要保证2个应用使用的是同一个aidl文件 (7)如何保证2 个应用使用的是同一个aidl文件谷歌要求 包名相同 (8)还是通过bindservice 方式去获取到中间人对象 (9)注意获取我们定义的中间人对象的方式不一样了,在服务连接对象ServiceConnection里的onServiceConnected方法里通过 stub 的一个静态方法去获取我们定义的中间人对象Stub.asinterface(Ibinder obj); AIDL的应用场景:支付宝 ▼用AIDL模拟调用支付宝服务里的服务方法: 第1步: 建立两个应用 第2步: 模拟支付宝服务(实际上支付宝是很复杂的) 先定义AIDL(相当于接口) 定义AIDL之后,程序会自动在gen目录下生成相同包名相同文件名的java文件,可以看到Java 文件中有一抽象类Stub,既继承了Binder类又实现了IService接口。这就是为什么下面服 务“中间人”是直接继承Stub的原因。 定义支付宝服务 注意要为服务配一个过滤器,指定一个action,因为支付宝服务要被另外一个应用所调用, 要用到隐式意图,那么就必须配置一个过滤器。 1 2 3 4 5 < service android:name = "com.itheima.service.PayService" > < intent-filter > < action android:name = "com.itheima.MY_ALI_PAY" /> </ intent-filter > </ service > 定义支付宝服务 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 /** *支付宝服务 */ public class PayService extends Service{ @Override public IBinderonBind(Intentintent){ //TODOAuto-generatedmethodstub return new MyBinder(); } //定义一个支付的方法 public boolean Pay(Stringusername,Stringpassword, double money) { //逻辑 System.out.println( "密码加密。。。。。。。。。" ); System.out.println( "检查手机有没有病毒。。。。。。。。。" ); System.out.println( "判断用户名和密码。。。。。。。。" ); System.out.println( "......" ); if (!(username.equals( "root" )&&password.equals( "1234" ))) { // Toast.makeText(getApplicationContext(),"密码错误.....",0).show(); System.out.println( "sdggsgggs" ); return false ; } if (money< 4000 ) { // Toast.makeText(getApplicationContext(),"豆子数不足4000.....",0).show(); System.out.println( "QQQQQQQQQQQ" ); return false ; } return true ; } //定义一个中间人对象与调用本地服务不一样,直接继承Stub类就可以了。 private class MyBinder extends Stub { @Override public boolean callPay(Stringusername,Stringpassword, double money) throws RemoteException{ return Pay(username,password,money); } } } 第3步: 在另外一个应用里调用支付宝服务 首先,将支付宝服务应用的aidl拷贝过来,并且包名要保持一致。 Activity调用支付宝服务的代码: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 public class MainActivity extends Activity{ //连接远程服务的连接对象 private MyConnconn= null ; //怎么才能将其它应用的IService得到呢,使用AIDL技术。 private IServiceserviceBinder= null ; @Override protected void onCreate(BundlesavedInstanceState){ super .onCreate(savedInstanceState); setContentView(R.layout.activity_main); //绑定服务-----------------注意这个逻辑要写在onCreate方法里,因为它需要一定的时间。 //由于是跨应用访问,要使用隐式意图。 Intentintent= new Intent(); intent.setAction( "com.itheima.MY_ALI_PAY" ); conn= new MyConn(); bindService(intent,conn,BIND_AUTO_CREATE); } public void click(Viewv) { try { boolean flag=serviceBinder.callPay( "root" , "1234" , 5000 ); //空指针,没有连接上。。。 if (flag) { System.out.println( "支付成功" ); } } catch (RemoteExceptione){ e.printStackTrace(); } } //定义一个类实现ServiceConnection接口 public class MyConn implements ServiceConnection { @Override public void onServiceConnected(ComponentNamename,IBinderservice){ System.out.println( "服务连接上了。。。。" ); serviceBinder=Stub.asInterface(service); } @Override public void onServiceDisconnected(ComponentNamename){ System.out.println( "服务连接失败。。。。" ); } } //解除绑定Service @Override protected void onDestroy(){ unbindService(conn); super .onDestroy(); } } 本文转自屠夫章哥 51CTO博客,原文链接:http://blog.51cto.com/4259297/1679401,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 29)——访问级别

访问级别: Swift提供了3种不同访问级别,对应的访问修饰符为:public、internal和private。这些访问修饰符可以修饰类、结构体、枚举等面向对象的类型,还可以修饰变量、常量、下标、元组、函数、属性等内容。 public。可以访问自己模块中的任何public实体。如果使用import语句引入其他模块,我们可以访问其他模块中的public实体。 internal。只能访问自己模块的任何internal实体,不能访问其他模块中的internal实体。internal可以省略,换句话说,默认访问限定是internal。 private。只能在当前源文件中使用的实体,称为私有实体。使用private修饰,可以用作隐藏某些功能的实现细节。 使用访问修饰符的示例代码如下: 1 2 3 4 5 6 7 public class PublicClass{} internalclassInternalClass{} private class PrivateClass{} public varintPublicVariable= 0 letintInternalConstant= 0 private funcintPrivateFunction(){} 使用最佳访问级别: 由于中Swift中访问限定符能够修饰的实体很多,使用起来比较繁琐,下面我们给出一些最佳实践。 1.统一性原则 原则1:如果一个类型(类、结构体、枚举)定义为internal或private,那么类型声明的变量或常量不能使用public访问级别。因为public的变量或常量可以被任何人访问,而internal或private的类型不可以。 原则2:函数的访问级别不能高于它的参数和返回类型(类、结构体、枚举)的访问级别。假设函数声明为public级别,而参数或者返回类型声明为internal或private,就会出现函数可以被任何人访问,而它的参数和返回类型不可以访问的矛盾情况。 2.设计原则 如果我们编写的是应用程序,应用程序包中的所有Swift文件和其中定义的实体,都是供本应用使用的,而不是提供其他模块使用,那么我们就不用设置访问级别了,即使用默认的访问级别。 如果我们开发的是框架,框架编译的文件不能独立运行,因此它天生就是给别人使用的,这种情况下我们要详细设计其中的Swift文件和实体的访问级别,让别人使用的可以设定为public,不想让别人看到的可以设定为internal或private。 3.元组类型的访问级别 元组类型的访问级别遵循元组中字段最低级的访问级别,例如下面的代码: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 private class Employee{ varno:Int= 0 varname:String= "" varjob:String? varsalary:Double= 0 vardept:Department? } structDepartment{ varno:Int= 0 varname:String= "" } private letemp=Employee() vardept=Department() private varstudent1=(dept,emp)① 4.枚举类型的访问级别 枚举中成员的访问级别继承自该枚举,因此我们不能为枚举中的成员指定访问级别。示例代码如下: 1 2 3 4 5 6 7 public enum WeekDays{ case Monday case Tuesday case Wednesday case Thursday case Friday } 由于WeekDays枚举类型是public访问级别,因而它的成员也是public级别。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746589,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 32)——计算属性

计算属性本身不存储数据,而是从其他存储属性中计算得到数据。 计算属性概念: 计算属性提供了一个getter(取值访问器)来获取值,以及一个可选的setter(设置访问器)来间接设置其他属性或变量的值。计算属性的语法格式如下: 1 2 3 4 5 6 7 8 9 10 11 12 面向对象类型类型名{ 存储属性 ...... var计算属性名:属性数据类型{ get{ return 计算后属性值 } set(新属性值){ ...... } } } 定义计算属性比较麻烦,要注意后面的几个大括号的对齐关系。 我们先看一个示例: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 import Foundation class Employee{ varno:Int= 0 varfirstName:String= "Tony" //存储属性 varlastName:String= "Guan" //存储属性 varjob:String? varsalary:Double= 0 lazyvardept:Department=Department() varfullName:String{ //计算属性 get{ return firstName+ "." +lastName //返回拼接的结果 } set(newFullName){ //存储传递进来的参数值 varname=newFullName.componentsSeparatedByString( "." ) firstName=name[ 0 ] lastName=name[ 1 ] } } } structDepartment{ letno:Int= 0 varname:String= "" } varemp=Employee() print(emp.fullName) //取出属性值 emp.fullName= "Tom.Guan" //给属性赋值 print(emp.fullName) 只读计算属性: 计算属性可以只有getter访问器,没有setter访问器,这就是只读计算属性。指定计算属性不仅不用写setter访问器,而且get{}代码也可以省略。与上一节相比,代码将大大减少。修改上一节示例为只读计算属性,代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Employee{ varno:Int= 0 varfirstName:String= "Tony" varlastName:String= "Guan" varjob:String? varsalary:Double= 0 lazyvardept:Department=Department() varfullName:String{ //简洁的setter访问器 return firstName+ "." +lastName } } structDepartment{ letno:Int= 0 varname:String= "" } varemp=Employee() print(emp.fullName) 只读计算属性不能够赋值,下列语句是错误的。 1 emp.fullName= "Tom.Guan" 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746597,如需转载请自行联系原作者

资源下载

更多资源
优质分享App

优质分享App

近一个月的开发和优化,本站点的第一个app全新上线。该app采用极致压缩,本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Nacos

Nacos

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

Rocky Linux

Rocky Linux

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

Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能,例如代码缩略图,Python的插件,代码段等。还可自定义键绑定,菜单和工具栏。Sublime Text 的主要功能包括:拼写检查,书签,完整的 Python API , Goto 功能,即时项目切换,多选择,多窗口等等。Sublime Text 是一个跨平台的编辑器,同时支持Windows、Linux、Mac OS X等操作系统。

用户登录
用户注册
修改密码
忘记密码