1、接口
接口中的访问权只能是public或者default；
接口中的属性默认为常量，即默认public final static 修饰；
接口中的方法默认为抽象方法，即默认public abstract 修改；由于界面是抽象的，界面不能实例化；
接口需要继承和实现，实现衍生和实现，继承派生需要重写方法，注意方法的权限必须是public；
类可以实现（implement）多个接口(多个接口用逗号分开)，如果有继承父类，先写继承句，再写实现句；
注意继承与实现的关系，只有同类之间的继承(界面可以继承界面)，不同类之间的实现(界面)；
接口设计规则：部分类需要将共同的抽象方法放入接口中；
/** 接口的演示 */ public class InterfaceDemo { public static void main(String[] args) { //Inter5 o1 = new Inter5(); //编译错误，接口不能实例化 Inter5 o2 = new Doo(); ////向上造型 Inter4 o3 = new Doo(); ////向上造型 } } ///演示接口继承接口 interface Inter4{ void show(); } interface Inter5 extends Inter4{ void test(); } class Doo implements Inter5{ public void test(){} public void show(){} } ///演示界面的多实现 interface Inter2{ void show(); } interface Inter3{ void test(); } abstract class Boo{ abstract void say(); } class Coo extends Boo implements Inter2,Inter3{ public void show(){} public void test(){} void say(){} } 实现//演示界面 interface Inter1{ void show(); //默认访问权限为public的 void test(); } class Aoo implements Inter1{ public void show(){} ///重写界面中的抽象方法，必须加public权限 public void test(){} } //演示界面语法 interface Inter{ ///默认接口中成员的访问权public的，也只能是public的 public static final int NUM = 5; public abstract void show(); int COUNT = 5; //默认public static final void test(); //默认public abstract //int number; //编译错误，常量必须同时声明 //void say(){ } ///编译错误，抽象方法没有方法 }2.面向对象三个特征
2.1、封装
类别：包装对象的属性和行为；
方法：封装的是具体的业务逻辑功能实现；
包装权限修饰符：包装是具体的访问权限；
2.2、继承
它最大的功能是重用代码，减少代码量；
超类：所有衍生物的共同属性和行为；（Object各类父类)
接口：部分衍生物的共同属性和行为；
派生类：派生类的独特属性和行为；
继承特征：单一继承（多接口实现），传递；
2.3、多态
对象的多继承：实现多个接口，对象接口实现类；
不同类型指向同一个对象时，能有不同的功能-----所有的对象都是多态的--------向上造型实现；
同一类型指向不同的对象，可以有不同的实现——所有抽象方法都是多态方法的重写；
对象向上建模后，能做的功能一般会比原来的类减少，所以有时候要做强制转换，强制转换有两个必要条件:
1)引用指向的对象是目标类型；
2)引用指向对象，实现目标类型的接口或继承；
不符合上述条件之一的，报异常：ClassCastException；
因此，在强转之前，我们通常会增加一个条件判断:(强转对象 instanceof 需要转换的类型)是否为true，为true转换；
package oopday09; public class MultiType { public static void main(String[] args) { /* 强转条件 */ Aoo aoo = new Boo(); ///向上造型 Boo boo =(Boo) aoo; // 强转型是同一类型 条件1 Inter inter = (Inter) aoo; ///强转型是继承或实现关系 条件2 // Coo coo = (Coo) aoo; // ClassCastException异常 if(aoo instanceof Coo){ Coo coo1 = (Coo) aoo; }else{ System.out.println("aoo不是Coo类型"); } } public static class Aoo { } public static class Boo extends Aoo implements Inter{ } public static class Coo extends Aoo { } public static interface Inter { } }3、内存管理
由JVM来处理，分部分：
1）堆：
对象：通过new当对象不再被引用时，它被称为垃圾；垃圾将被引用GC不定期回收，可使用System.gc() 建议gc尽快回收；
实例变量的声明周期：与对象共存，对象为gc清洗后，实例变量消失；
内存泄漏：不再使用的对象（指向引用）未及时使用GC回收利用；严重泄漏会导致系统崩溃；因此，引用不再使用的对象设置为null；
2）栈
存储调用方法的局部变量(包括方法的参数)存在于该方法(包括main方法)开辟的栈帧；方法调用后，栈帧中的方法和局部变量随栈帧一起清除；
局部变量的生命周期：调用方法时开始，存在栈帧中，方法调用结束后，与栈帧一并被清除；
3）方法区
存储.class字节码文件(静态变量和方法)；
只有一种方法，通过this区分具体调用对象；
4、String类(字符串)
java.lang：(语言包)放入最常用的类别lang中，包括了String并自动导入；
java.lang.String：底部包装是一个字符数组，使用final修改，不能继承，一旦创建就不能改变；
String内存中使用的是Unicode编码格式，每个字符占用两个字节；
字符串常量池：
java对String字符串有优化措施：字符串常量池（）
String s3 = "abc" "abc"; //两直接量相加，在常量池中创建引用 String s33 = "abcabc"; System.out.println(s3 == s33); //true s3 = s1 "abc"; //有变量参与，只能创建新的对象 System.out.println(s3 == s33); //false char[] charArr = new char[1];
System.out.println(charArr.length);
String chars = " ";
System.out.println(chars.length()); trim()
注意String是一个不变变量，String 变量名.trim() 相当于创建了一个新的对象，该对象
实现了trim() 功能，去掉了两边空格，而原来的变量引用的对象没变；
所以对于有返回值的方法，我们优先考虑接受返回值
*/
String str = " Hello World";
System.out.println(str.trim());
System.out.println(str);
str = str.trim(); //接受返回值
System.out.println(str);String str1 = "我在学Java";
str1 = str1.toUpperCase();
System.out.println(str1);
str1 = str1.toLowerCase();
System.out.println(str1);String str02 = "thinking in java";
boolean starts = str02.startsWith(" think");
System.out.println(starts);String str03 = str02;
System.out.println(str03.charAt(5));、
当字符串不存在指定字符时，则返回-1；
int index = str02.indexOf("in");
int index02 = str02.lastIndexOf("in");
System.out.println(index);
System.out.println(index02);
int index03 = str02.indexOf("in",3);
System.out.println(index03);
int index04 = str02.indexOf("ab");
System.out.println(index04);
String str02 = "thinking in java";
String nun = str02.substring(9,11);
System.out.println(nun); //in在String类中，由于String是个不可变的数据，每次修改String都要重新建对象，造成了内存占用过高、效率低下的问题；而StringBuilder类则解决了该问题。
StringBuilder是一个java.lang中的类，里面维护了一个可变的字符数组，专门用于修改数组；该类建立对象一定要用构造器，不能单写直接量，这点与String有所不同；
StringBuilder的构造对象方法：
StringBuilder builder1 = new StringBuilder(); //空字符串
StringBuilder builder2 = new StringBuilder("abc");
String s4 = "abc";
StringBuilder builder3 = new StringBuilder(s4);
StringBuilder的常用方法：
append(数据类型 数据)：追加内容，builder方法的特点是直接在对象数据上操作，与String那种先建对象再操作相比，可以去掉接收返回值这个操作；
builder2.append(",def");
System.out.println(builder2); //abc,defreplace(int start,int end,String s)：替换指定作用范围的内容，和String一样，是含头不含尾；
builder2.replace(4,7,"ghi");
System.out.println(builder2);//abc,ghidelete(int start,int end)：删除指定范围内的字符串，含头不含尾；
builder2.delete(3,7);
System.out.println(builder2); //abcinsert(int index,String s)：在指定下标处的后面，插入指定的字符串；
builder2.insert(3,",xyz");
System.out.println(builder2); //abc,xyz9、StringBuilder与StringBuffer的区别（需要线程的知识）
StringBuilder:非线程安全，并发处理的，性能较好，在jdk1.5开始用
StringBuffer：线程安全，是同步处理的，性能较差，在jdk1.0就用了
5、正则表达式
1、[ ]：表示一个字符，该字符可以是[ ]中指定的内容
[abc]：这个字符可以是a或b或c； [a-z]：表示任意一个小写字母； [a-zA-Z：:表示任意一个字母； [a-zA-Z0-9]：表示任意一个字母数字； [a-zA-Z0-9_]：表示任意一个数字字母下划线； [^abc]：该字符只要不是a或b或c；
2、预定义字符
。：表示任意一个字符,没有范围限制 \d：表示任意一个数字,等同于[0-9] \w：表示任意一个单词字符,等同于[a-zA-Z0-9_]--单词字符指字母/数字/_ \s：表示任意一个空白字符 \D：表示不是数字 \W：不是单词字符 \S：不是空白字符
3、量词
?：表示前面的内容出现0-1次 例如: [abc]? 可以匹配:a 或 b 或 c 或什么也不写 +：表示前面的内容最少出现1次 例如: [abc]+ 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcba.... 但是不能匹配:什么都不写 或 abcfdfsbbaqbb34bbwer... *：表示前面的内容出现任意次(0-多次)---匹配内容与+一致，只是可以一次都不写 例如: [abc]* 可以匹配:b或aaaaaaaaaa...或abcabcba....或什么都不写 但是不能匹配:abcfdfsbbaqbb34bbwer... {n}：表示前面的内容出现n次 例如: [abc]{3} 可以匹配:aaa 或 bbb 或 aab 或abc 或bbc 但是不能匹配: aaaa 或 aad {n,m}：表示前面的内容出现最少n次最多m次 //下课--------------10:12继续 例如:：[abc]{3,5} 可以匹配:aaa 或 abcab 或者 abcc 但是不能匹配:aaaaaa 或 aabbd {n,：表示前面的内容出现n次以上(含n次) 例如: [abc]{3,} 可以匹配:aaa 或 aaaaa.... 或 abcbabbcbabcba.... 但是不能匹配:aa 或 abbdaw...
( ) ：用于分组,是将括号内的内容看做是一个整体 例如: (abc){3} 表示abc整体出现3次. 可以匹配abcabcabc 但是不能匹配aaa 或abcabc (abc|def){3}表示abc或def整体出现3次. 可以匹配: abcabcabc 或 defdefdef 或 abcdefabc 但是不能匹配abcdef 或abcdfbdef
4、常用方法
matches("regex")：验证是否匹配正则表达式；
String regex ="[a-zA-Z0-9]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
// String regex =" [a-zA-Z0-9]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+"; //注意空格也是个字符
String email = "xxxxx@163.com";
public static void main(String[] args) {
RegexDemo r = new RegexDemo();
System.out.println(r.email.matches(r.regex)); //truerepalceAll("regex"，String s)：将符合正则表达式的字符串替换成指定的字符串s；
String line = "abc123def456ghi78";
line = line.replaceAll("[0-9]","#NUNMBER#");
System.out.println(line); //abc#NUNMBER##NUNMBER##NUNMBER#def#NUNMBER##NUNMBER##NUNMBER#ghi#NUNMBER##NUNMBER#split("regex") ：在符合regex的位置拆分字符串，它有三个特点：
最开始有拆分元素，前面会有一个空串；
中间有两个连续的（或以上）的可拆分元素，也会在可拆分元素之间生成空字符串；
最后有连续的可拆分元素，拆分出来的空字符串会被忽略；
String line1 = ".123.456..78....";
String[] data = line1.split("\\.");
System.out.println(Arrays.toString(data));//[, 123, 456, , 78]6、类重写toString（）、equals()
Object类：返回：类的全称@地址；
String、StringBuilder类都重写了toString()，并返回了一个固定格式的字符串，里面打印了类的属性；
Object类：判断类地址是否相等；
String，类重写了equals()，判断内容是否相等；但是StringBuilder类并没有重写equals()；
注意：equals()即使重写了，也要是在同类型的前提下，再去比较内容是否相同；如果连类型都不一致，那判断结果不管是否有重写都是false；
7、包装类
Integer、Character、Byte、Short、Long、Boolean、Float、Double
Boolean、Character直接继承于Object类，剩下六个是继承于java.lang.Number类的；
Integer有一个节约内存的特点， 若是用valueOf()来建立对象时，可以复用一个字节数据大小（-128~127）的对象，从而节约内存；若用new Integer()来创建对象，则没有节约内存的功能；
JDK1.5推出了一个新特性：自动拆装箱
当编译期发现你在用基本类型与包装类相互赋值时，会自动拆、包装成对应的类型：
Integer i = 5;
//Inter i = Integer.valueOf(5);自动装箱：把一个基本类型赋值给包装类中
int j = i;
//int j = i.intValue();自动拆箱，把一个包装类赋值给基本类型包装类.MAX_VALUE：获取最大值
包装类.MIN_VALUE：获取最小值
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;
System.out.println("int的最大值为"+max+",最小值："+min);
String s1 = "38";
int age = Integer.parseInt(s1); //将s1转换为int类型
System.out.println(age); //38----int
String s2 = "123.456";
double price = Double.parseDouble(s2);
System.out.println(price);