第2天至第20天

day02


二、类和对象


30.对象的三个特性（OOP）：
a.对象的行为 b.对象的状态  c.对象的标识


31.继承： is a


32.所有的方法都必须在类的内部定义，在C++中可以在内部，也可以在外部


33.static不能操作对象，尽量用类名调用静态方法而不是对象名。（其实都没错，但为了避免混淆）


34.使用静态的方法：
a.一个方法不需要访问对象状态，其所需的参数同事通过显式参数提供
b.一个方法只需要访问类的静态域


35.一个方法无法改变基本数据类型（注意一定是基本！！！）的参数，如下：
public static void tripleValue(double x){
x=3*x;
}
double percent =10;
tripleValue(percent);
percent的值仍为10，无法改变


36.如果对象引用作为参数，就可以：
public static void tripleSalary(Employee e){
e.raiseSalary(200);
}
harry = new Employee(...);
tripleSalary(harry);
最终薪水会改变为3倍


37.在java中this引用可以等价于c++的this指针，可以在构造器中调用另外一个构造器，但是在C++中，一个构造器不能调用另外一个构造器。


day03


38.//随机数的集中用法,注意这几种方法都是右区间都是闭的
int r = (int )(Math.random()*10+1);
System.out.println("第一种："+r);

Random ran = new Random();
int g = ran.nextInt(10)+1;
System.out.println("第二种："+g);


39.使用包的主要原因是保证类名的唯一性--相同的类放在不同的包中就不会起冲突，嵌套的包没有任何关系，例如java.util和java.util.jar这两个包没有关系，必须同时都导入；
例外可以不需要导入包而直接使用，如java.util.Date


40.静态导入：
import static java.lang.System.*;
就可以使用System类中的静态域和静态方法，不需要加类名前缀
ex:导入前：System.out.println();静态导入后：out.println();


41.所有的继承都是共有继承。


42.子类中的一些方法并不能用基类中的方法来使用，因此要在子类中重新覆盖（override）


43.this的用法：1、引用隐式参数 2、调用该类其他的构造器
   super的用法：1、调用超类的方法 2、调用超类的构造器


44.基类可以引用子类，假设boss是子类，Employee1是基类，可以Employee1 = boss，但是Employee不能调用子类中的方法，
   boss = Employee1 这样不行，即子类不能应用基类；如果非要这么做必须进行类型转换：boss = (Employee)Employee1


45.子类可以转化为基类


46.用super来调用基类中的方法，避免与子类中的方法重复


47.类前加final就是不能覆盖基类的方法,也就是不能被继承


48.进行类型转是，应该先判断是否能够成功地转换，用Instanceof实现
if（stafff[1] instanceof Mangager）{
boss = (Manager) staff[1]
}
staff类型是基类


49.只有在继承层次内进行类型转换


50.进行类型转换的情况一般是要使用子类中的特有方法，才如此做！


51. 抽象类不能被实例化，即将一个类声明为抽象时，就不能创建类的对象例如表达式：new person（"Vince Vu"）
    可以定义一个抽象类的对象变量，但是它只能引用非抽象子类的对象，例如：Person p = new Student ("""");
    p是抽象类的变量，Person引用了一个非抽象子类Student实例


52.Object是所有类的始祖！！！


day04


53.抽象的方法不能是private，只能是protected和public


54.抽象类中的方法在子类中一定要有具体实现，另外在子类中一定要对基类进行初始化


55.String a= "ab"和String b = new String（"ab"）注意二者区别
直接赋值只会在检查String池中的字符串，如果有，不在池中添加，如果没有就在池中创建一个“ab”的字符串
只要使用new 来创建对象，则一定会在（堆区或栈区）创建一个新的对象
使用包含变量的表达式来创建String的对象，则不仅会检查维护String池，而且还会在堆栈中创建一个String对象


56.equals方法是比较变量的内容（a.equals("")）.而a==b比较的是对象的引用是否相同，即使内容相同，变量不同也返回 false


57.java中if(TextUtils.isEmpty(number)||TextUtils.isEmpty(content))不能写成if(TextUtils.IsEmpty(number&&content))
判断content或number是否为空，其中一个为空则返回false


58.当一个类不允许new的时候即在new的时候回报错，则可能存在getDefault()方法---android中
实例：SmsManager smsManager = SmsManager.getDefault();


59.封装的访问控制权限：
---------------------------------------------------------------------
|修饰符      同一个类内     同一个包内      子类       所有类       |
|-------------------------------------------------------------------|                                                                          | 
|public      允许访问       允许访问        允许访问   允许访问     |
|-------------------------------------------------------------------|                                                                          |
|protected   允许访问       允许访问        允许访问                |
|-------------------------------------------------------------------|                                                                          |
|default     允许访问       允许访问                                |
|-------------------------------------------------------------------|                                                                          |
|private　　 允许访问                                               |
---------------------------------------------------------------------


60.接口实现多重继承


61.接口中的所有方法自动属于public,因此在接口中申明方法时，不必提供关键字public


62.接口不能含有实例域，也不能在接口中实现方法，提供实例域和方法应该有实现接口的那个类来完成


63.为了让类实现一个接口：
a.将类声明为实现给定的接口
b.对接口中的所有方法的定义


64.接口不是类，尤其不能使用new运算符实例化一个接口


65.有几个new就有几个对象


66.构造器是不能继承的


67.静态方法一般是使用类名来调用，是属于类的方法，静态方法没有隐含参数（this）


68.false,true,null不是关键子，是字面量


69.私有的方法不能继承，也不能重写（可以同名，但是不算重写方法）


70.toString是Object类定义，子类默认继承的方法


71.包含抽象方法的类一定是抽象类


72.Uoo m = new Uoo(){};（分号不能掉）创建匿名内部类实例，继承与Uoo的子类，并且同时创建了子类型的实例,{}是子类实体


73.内部类是私有的！！！


74.在匿名内部类中只能访问final变量


75.在方法中定义的类为局部类，局部类能访问final类型的变量，不能被public和private修饰


76.hashcode为虚拟地址，称作句柄，是一串16进制数，不是内存地址


77.equals方法比较的是对象而不是方法


78.String str1 = new String("abc");
   System.out.println(str1.equals("abc"));true


79.equals比较的是两个对象内容是否一样，==比较的是是否为同一个对象(字符串是特例)
String str1="abc" String str2="abc" str1==str2返回true
但是如果String str1 = new String("abc")则返回false,所以比较字符串相等时尽量使用equals
80.字符串类是不可变的（day17）
   * 字符串对象是不可变的
   * 任何对字符串对象的改变，都会重新创建对象，而不是影响原来的对象
   * 于是s1引用的是新对象，而不是原来的对象，原来的对象被gc回收


81.字符串String是引用类型，一旦我们要创建字符串时，虚拟机先检查常量池里面是有这个字符串，有就直接引用这个字符串，没有就创建新的对象。所以对字符串的改变会创建新的对象


81. /** 其实这样写不妥，如果是s1是null则会报错 */
if(s1.equals("Hello"))
System.out.println("这个字符串相等");
//最好这样写
if("Hello".equals(s1))
System.out.println("这个字符串相等");
、
82.忽略大小写的比较方法equalsIgnoreCase(s1)


83.字符串的常用方法：
equals(),trim（），toLowerCase(),toUpperCase(),length();startsWith(),endsWith();indexOf()和lastIndexOf()方法
char charAt(int index)方法返回指定位置的单个字符
subString(int start,int end) 截取字符串，包前不包后


84. getBytes()返回字符串相应的字节，将字符串转换为字节数组并返回


85.正则表达式--规定字符串的格式


一：
-------------------------------------------------------------------
[abc]           a,b，c中任意一个字符
[^abc]          除了abc以外的任何字符
[a-z]           a,b,c,...z的任意一个字符
[a-zA-Z0-9]     a到z,A到Z,0到9
[a-z&&[^bc]]    a到z中除了bc的任意一个字符 


二、
-------------------------------------------------
X?     表示0个或1个X
X*     表示0个或多个X
X+     表示0个或任意个X(大于等于)
X{n}   表示n个X
X{n,}  表示n个到任意多个X(大于等于n)
X{n,m} 表示n个到m个X（大于等于n个且小于m个X）




/** 正则表达式 */
String pattern = "[a-zA-Z0-9]+@[a-zA-Z0-9]+(\\.com|\\.net|\\.cn)";
//使用+的意思是至少有一个，不能没有，注意这里的+的含义
System.out.println(pattern);
//输出结果是[a-zA-Z0-9]+@[a-zA-Z0-9]+(\.com|\.net|\.cn)，然后 \. 转义后就成了 . 没有\了，也就是双重转义，注意！！！
//注册正则表达式
Pattern patt = Pattern.compile(pattern);
String _str = "[email protected]";
//匹配字符串，返回描述匹配结果的matcher实例
Matcher matcher = patt.matcher(_str); 
if(matcher.find())
System.out.println("邮箱格式正确！！！");
else
System.out.println("邮箱格式错误！！！");


^:开头必须以后面约束的开始
￥：字符必须以前面的约束内容开始


//注意，\d表示数字，所以经过二重转义是\\d，如果前后加^和$表示全匹配
String regPhoneNum = "^\\d{11}$";
//或者是^（\\+86）？\\d{11}$
//先注册
Pattern patt_Num = Pattern.compile(regPhoneNum);
//在匹配
String num1 = "12364730386";
String num2 = "123zadf219374";
String num3 = "1330970582711111";
Matcher matcher1 = patt_Num.matcher(num1);
Matcher matcher2 = patt_Num.matcher(num2);
Matcher matcher3 = patt_Num.matcher(num3);
System.out.println(matcher1.find());
System.out.println(matcher2.find());
System.out.println(matcher3.find());
输出结果：
true
false
false


86.spilt("")方法，拆分字符串
String str1 = "I!LOVE!JAVA";
String[] array = str1.split("!");
for(String e: array)
System.out.println(e);


87.求数组长度，str.lengt
   求字符串的长度str.length()


88.replaceAll(regex,replacement)
第一个参数是正则表达式，第二个参数是替换的内容


89.StringBuilder方法
测试replace(int start,int end,String str)
/** delete(int start,int end) 不包括尾部*/
append("")


89.
/**
* StirngBuffer 和StringBuilder的区别就是
* StringBuilder是线程不安全的
* StringBuffer是线程安全的
* 
* */


90.SimpleDateFormat所表示的日期格式：
yyyy-MM-dd
yy-MM-dd
yyyy-MM-dd hh:mm.ss.


HH代表24小时制hh代表12小时制的
 /**
 * 创建一个DateSimpleFormat并告诉它要读取的字符串的格式
 */
SimpleDateFormat sdf =  new SimpleDateFormat("yyyy-MM-dd");
//创建一个字符串日期
String timeSource = "2016-02-23";
time = sdf.parse(timeSource);
System.out.println(time);
 
 
/** 我们也可以反向操作将一个Date日期转换成它所描述的字符串
* 转换出来的格式是SImpleDateFormat的规定的格式*/
String str = sdf.format(time);
System.out.println(str);
/**
 * 将日期转换成yyyy/MM/dd
 * */
sdf = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
str = sdf.format(time);
System.out.println(str);