极客学院android（一）-----JAVA编程基础知识入门

1.二进制补码

  ①计算机中负数等于整数二进制取反+1，整数加上负数等于模。模：某种类型数据的总数，例如四位二进制的模2的四次=16   2的二进制为0010  -2的二进制为1110  2+（-2）=0010+1110=10000即2的四次16

2.转义符

‘\n’：表示回车，    ‘\t’：表示制表符，一个制表符表示向右跳转8-10个字符，即大概5个空格的位置，   ‘\\’：表示\，    ‘\'’：表示单引号，    ‘\"’：表示双引号。

3.小类型向大类型的转换

① int 32位，最高位是符号位，31位表示精度 float 32位 第一位表示数字的符号，2-9位来表示指数，用最后23位来表示尾数。对于64位的double，第一位表示数字的符号，11位表示指数，52位表示尾数。 int转为float可能会出现精度丢失。int是整型，用来表示整数，其值是精确值。float是浮点型，用来表示实数，其值是近似值。所以int转float是由准确值变成了近似值，所以会丢失精度。

    int i=ox1000001 4x7=28位大于float的23位精度。 float f=i；System.out.printfln(Interger.toBinaryString((int)f));

②强制类型转换byte b=5; b=(byte)(b+10),b+10会自动转换成int，所以要强换成byte。而b=5+10无类型转换。

③大类型转换成小类型，源数据的数据位变为目标数据的符号位。 int i=129;byte b= (byte)i byte 127

   129转换成二进制为1000,0001 按位取反加一 01111111  -127

④大类型数据超过小类型的位数实例： int i=257;byte b= (byte)i  ;1,0000,0001   byte取8位 0000,0001抛弃最高位结果为1.

4.Scanner控制台输入char

   调用scanner.next().charAt(0);

5.交换两个变量的值

int a,b; 
a=10; b=15; 
int t; 
t=a; a=b; b=t; 
这种算法易于理解，特别适合帮助初学者了解计算机程序的特点，是赋值语句的经典应用。

简单来说，就是通过普通的+和-运算来实现。代码如下： 
int a,b; 
a=10;b=12; 
a=b-a; //a=2;b=12 
b=b-a; //a=2;b=10 
a=b+a; //a=12;b=10 
通过以上运算，a和b中的值就进行了交换。表面上看起来很简单，但是不容易想到，尤其是在习惯标准算法之后。 
它的原理是：把a、b看做数轴上的点，围绕两点间的距离来进行计算。 
具体过程：第一句“a=b-a”求出ab两点的距离，并且将其保存在a中；第二句“b=b-a”求出a到原点的距离（b到原点的距离与ab两点距离之差），并且将其保存在b中；第三句“a=b+a”求出b到原点的距离（a到原点距离与ab两点距离之和），并且将其保存在a中。完成交换。 

6.switch的贯穿现象

  只要每个case不写break，循环就会一直执行下去，包括defaul里的语句。

package alzhai.com;

public class Alzhai15 {
/**
* @param args
*/
public static void main(String[] args) {
int zha=4;
switch (zha) {
case 5://贯穿下去，这个时候是4，因为没有back,就继续贯穿下去
zha++;
case 4://这里显示5
zha++;
case 3://这里显示6
zha++;
case 2://这里显示7
zha++;
case 1://这里显示8
zha++;
case 0://这里显示9
zha++;
default:
System.out.println(zha);//最终结果显示9
}
}
}

7.&：长路与运算：会把两边的关系运算结果都计算出来

   &&：当运算符左边的关系运算结果是false时不再对右边的关系运算进行运算，提高运算效率

8.三种逻辑运算优先级：

   非运算优先级最高，其次是与运算，优先级最低的是或运算。

9.用while打印所有的大写英文字母和对应的unicode码

解法一：int i=65;while(i<65+25){

               System.out.println((char)i+"  i="+i);

               i++;

             }

解法二：

              char c='A';while(c<'Z'){

               System.out.println(c+"  c="+(int)c);

               c++;

             }

10.math类的常用用法总结

//取整，返回小于目标函数的最大整数,如下将会返回-2Math.floor(-1.8)；//取整，返回发育目标数的最小整数Math.ceil()//四舍五入取整Math.round()//计算平方根Math.sqrt()//计算立方根Math.cbrt()//返回欧拉数e的n次幂Math.exp(3);//计算乘方,下面是计算3的2次方Math.pow(3,2);//计算自然对数Math.log();//计算绝对值Math.abs();//计算最大值Math.max(2.3,4.5);//计算最小值Math.min(,);//返回一个伪随机数，该数大于等于0.0并且小于1.0Math.random

11.类是对某一事物的描述，是抽象的，概念上的意义。对象是具体的，是实际存在的的每一个实体，也被称之为实例。

12.java构造方法的使用注意：

  ①构造方法的名称必须与类名一致

  ②构造方法没有返回值，只要是为类进行初始化。

   每个类在被实例化后都会调用构造方法，如果没有构造方法，程序在编译的时候会创建一个无参的什么都不做的构造方法。构造方法也可以重载。

13.继承的限制：

    ①在java中只允许单继承，相当于一个孩子只能有一个亲生父亲。

    ②子类不能直接访问父类的私有成员，只能通过实现get和set方法实现对私有变量的修改。

14.子类对象实例化过程先执行父类的构造方法再执行子类的构造方法。

属性、方法、构造方法和自由块都是类中的成员，在创建对象时，各成员的执行顺序如下：

（1）父类静态成员和静态初始化块，按在代码中出现的顺序依次执行。

（2）子类静态成员和静态初始化块，按在代码中出现的顺序依次执行。

（3）父类实例成员和实例初始化块，按在代码中出现的顺序依次执行。

（4）执行父类构造方法。

（5）子类实例成员和实例初始化块，按在代码中出现的顺序依次执行。

（6）执行子类构造方法。

详细分析详见http://blog.csdn.net/mafei852213034/article/details/54755108

15.重写的限制：

  被子类重写的方法不能拥有比父类更加严格的访问权限

  private<default<public 例如父类某个方法是default 子类如果重写的话只能是   default或者public  不能是private

16.方法中使用super关键字强制调用父类的方法。

17。重写与重载 

override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父时，重写（重新实现）父类中的方法。
重写（覆盖）的规则：


   1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.

   2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。

   3、重写的方法的返回值必须和被重写的方法的返回一致；

   4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；

   5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没s有对其进行重写。

   6、静态方法不能被重写为非静态的方法（会编译出错）。

overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。
重载的规则：
   1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
   2、不能通过访问权限、返回类型、抛出的异常进行重载；
   3、方法的异常类型和数目不会对重载造成影响；
多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。

一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。

18.final

  final能声明类、方法、属性，使用final声明的类不能被继承，使用final声明的方法不能被重写，使用final声明的变量变为常量，常量是不可以被修改的。

19.abstract抽象和接口

 抽象类被子类继承，子类（如果不是抽象类）必须重写抽象类中的所有抽象方法，抽象类不能被实例化。

 接口里面都是由全局常量和公共的抽象方法组成，接口的实现必须通过子类，使用关键字implements 而且接口是可以多实现的，一个接口不能继承一个抽象类但是却可以通过extends同时继承多个接口，实现接口的多继承。

20.==和equals的区别 

总结来说：

　　1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

　　　　如果作用于引用类型的变量，则比较的是所指向的对象的地址

　　2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量

　　　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

　　　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容

21.string常见的用法

java中String的常用方法 
1、length() 字符串的长度 
　　例：char chars[]={'a','b'.'c'}; 
　　　　String s=new String(chars); 
　　　　int len=s.length(); 

2、charAt() 截取一个字符 
　　例：char ch; 
　　　　ch="abc".charAt(1); 返回'b' 

3、 getChars() 截取多个字符 
　　void getChars(int sourceStart,int sourceEnd,char target[],int targetStart) 
　　sourceStart指定了子串开始字符的下标，sourceEnd指定了子串结束后的下一个字符的下标。因此， 子串包含从sourceStart到sourceEnd-1的字符。接收字符的数组由target指定，target中开始复制子串的下标值是targetStart。 
　　例：String s="this is a demo of the getChars method."; 
　　　　char buf[]=new char[20]; 
　　　　s.getChars(10,14,buf,0); 
4、getBytes() 
　　替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()。 
5、toCharArray() 
6、equals()和equalsIgnoreCase() 比较两个字符串 
7、regionMatches() 用于比较一个字符串中特定区域与另一特定区域，它有一个重载的形式允许在比较中忽略大小写。 
　　boolean regionMatches(int startIndex,String str2,int str2StartIndex,int numChars) 
　　boolean regionMatches(boolean ignoreCase,int startIndex,String str2,int str2StartIndex,int numChars) 
8、startsWith()和endsWith()　　startsWith()方法决定是否以特定字符串开始，endWith()方法决定是否以特定字符串结束 
9、equals()和== 
　　equals()方法比较字符串对象中的字符，==运算符比较两个对象是否引用同一实例。 
　　例：String s1="Hello"; 
　　　　String s2=new String(s1); 
　　　　s1.eauals(s2); //true 
　　　　s1==s2;//false 
10、compareTo()和compareToIgnoreCase() 比较字符串 
11、indexOf()和lastIndexOf() 
　　indexOf() 查找字符或者子串第一次出现的地方。 
　　lastIndexOf() 查找字符或者子串是后一次出现的地方。 
12、substring()　　它有两种形式，第一种是：String substring(int startIndex) 
　　　　　　　　 第二种是：String substring(int startIndex,int endIndex) 
13、concat() 连接两个字符串 
14 、replace() 替换 
　　它有两种形式，第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换，形式如下： 
　　String replace(char original,char replacement) 
　　例如：String s="Hello".replace('l','w'); 
　　第二种形式是用一个字符序列替换另一个字符序列，形式如下： 
　　String replace(CharSequence original,CharSequence replacement) 
15、trim() 去掉起始和结尾的空格 
16、valueOf() 转换为字符串 
17、toLowerCase() 转换为小写 
18、toUpperCase() 转换为大写 
19、StringBuffer构造函数 
　　StringBuffer定义了三个构造函数： 
　　StringBuffer() 
　　StringBuffer(int size) 
　　StringBuffer(String str) 
　　StringBuffer(CharSequence chars) 
　　(1)、length()和capacity()　　　　一个StringBuffer当前长度可通过length()方法得到,而整个可分配空间通过capacity()方法得到。 
　　(2)、ensureCapacity() 设置缓冲区的大小 
　　　　void ensureCapacity(int capacity) 

　　(3)、setLength() 设置缓冲区的长度 
　　　　void setLength(int len) 

　　(4)、charAt()和setCharAt() 
　　　　char charAt(int where) 
　　　　void setCharAt(int where,char ch) 
　　(5)、getChars() 
　　　　void getChars(int sourceStart,int sourceEnd,char target[],int targetStart) 
　　(6)、append() 可把任何类型数据的字符串表示连接到调用的StringBuffer对象的末尾。 
　　　　例：int a=42; 
　　　　　　StringBuffer sb=new StringBuffer(40); 
　　　　　　String s=sb.append("a=").append(a).append("!").toString(); 
　　(7)、insert() 插入字符串 
　　　　StringBuffer insert(int index,String str) 
　　　　StringBuffer insert(int index,char ch) 
　　　　StringBuffer insert(int index,Object obj) 
　　　　index指定将字符串插入到StringBuffer对象中的位置的下标。 
　　(8)、reverse() 颠倒StringBuffer对象中的字符 
　　　　StringBuffer reverse() 
　　(9)、delete()和deleteCharAt() 删除字符 
　　　　StringBuffer delete(int startIndex,int endIndex) 
　　　　StringBuffer deleteCharAt(int loc)

　　(10)、replace() 替换 
　　　　StringBuffer replace(int startIndex,int endIndex,String str) 
　　(11)、substring() 截取子串 
　　　　String substring(int startIndex) 
　　　　String substring(int startIndex,int endIndex) 
例子： 
//String所给出的方法均可以直接调用 
public class Test{ 
public static void main(String[] args){ 
String s = "Welcome to Java World!"; 
String s1 = " sun java "; 
System.out.println(s.startsWith("Welcome"));//字符串以Welcome开头 
System.out.println(s.endsWith("World"));//字符串以World结尾 
String sL = s.toLowerCase();//全部转换成小写 
String sU = s.toUpperCase();//全部转换成大写 
System.out.println(sL); 
System.out.println(sU); 
String b = s.substring(11);//从第十一位开始 
System.out.println(b); 
String c = s.substring(8,11);//从第八位开始在第十一位结束 
System.out.println(c); 
String d = s1.trim();//去掉首尾的空格 
System.out.println(d); 
String s2 = "我是程序员，我在学java"; 
String e = s2.replace("我","你"); 
System.out.println(e); 
int f = 5; 
String s3 = String.valueOf(f); 
System.out.println(s3); 
String s4 = "我是,这的,大王"; 
String[] g = s4.split(","); 
System.out.println(g[0]); 
当把字符串转换成基本类型时，例如，int，integer.praseInt(String s) 
当把基本类型转换成字符串时，例如，static String valueOf(int i)

22.多态的向上转型和向下转型

Java 转型问题其实并不复杂，只要记住一句话：父类引用指向子类对象。
什么叫父类引用指向子类对象，且听我慢慢道来.
从2个名词开始说起：向上转型(upcasting) 、向下转型(downcasting).
举个例子：有2个类，Father是父类，Son类继承自Father。
Father f1 = new Son();   // 这就叫 upcasting （向上转型)
// 现在f1引用指向一个Son对象
Son s1 = (Son)f1;   // 这就叫 downcasting (向下转型)
// 现在f1还是指向Son对象
第2个例子：
Father f2 = new Father();
Son s2 = (Son)f2;       // 出错，子类引用不能指向父类对象
你或许会问，第1个例子中：Son s1 = (Son)f1;问什么 是正确的呢。
很简单因为f1指向一个子类对象，Father f1 = new Son(); 子类s1引用当然可以指向子类对象了。
而f2 被传给了一个Father对象，Father f2 = new Father（）；子类s1引用不能指向父类对象。
总结：
1。父类引用指向子类对象，而子类引用不能指向父类对象。
2。把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转换。
      如：Father f1 = new Son();
3。把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting)，要强制转换。
   如：f1 就是一个指向子类对象的父类引用。把f1赋给子类引用s1即 Son s1 = (Son)f1；其中f1前面的(Son)必须加上，进行强制转换

23.instanceOf

Java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。