1.package regex1;
public class Test {
public static void main(String[] args) {
p("abc".matches("..."));
p("a324b".replaceAll("\\d","-"));
}
public static void p(Object o) {
System.out.println(o);
}
}
Tips:主方法与辅助方法各自分别有{}。即主方法不应包括辅助方法p。
2.compile 编译
3.转译字符\（单斜杠）在正则表达式里面应为双斜杠\\。（java里不存在一个反斜线，必须用两个反斜线代替）。
4.正则表达式API位置： java.util.regex
大括号： \\d{1,3} 表示数字数量在1个到3个之间 ；\\d{3}表示三个数字。不加\\d不表示数 字。
中括号： [1-3] 表示数字在1到3之间（匹配中括号之间的一个字符）。
Tips: 表示数字的括号中间是横杠，表示数量的括号中间是逗号。
[^abv] 表示除了abv 之外的其他字母（^在中括号外边代表”行的开头”、在里面表示“非”）。
[a-zA-Z]、[a-z]|[A-Z]、[a-z[A-Z]]三中表示方法均表示字母在a-z或A-Z之间。
[A-Z&&[RFG]]表示不仅在A-Z之间而且在RFG 当中的一个。
a*代表0或多次，a?代表0或1次，a+代表0或1次。
\w单词字符用于注册用户名,[a-zA-Z_0-9]。
两例子： 关于边界匹配器java.util.regex.pattern
空白行的表示方法：p(“ \n”.matches(“^[\\s&&[^\\n]]*\\n$”));
解释：空格开始换行结束（空白行） 匹配 以空白字符且非换行符（因为空白字符中包括换行符）开始0次或多次以换行符结束
Tips:\\b边界字符(boundary)
\\d数字字符（digit）
一般邮箱的正则表达式：”^[\\w[,-]]+@[\\w[,-]]+\\.[\\w]+”
5. matches: 匹配整个字符串
find: 找子串（找完一个子串，找下一个。子串用—分隔开）
在可以找到子串的前提下（否则报错）：调用start()end()方法输出子串起始末尾点。
looking At: 每次从头开始找
注意：在续用matches和find时，中间用reset隔开。否则会影响输出结果。
6.错误总结 ： cannot be resolved to a type
的字面意义是无法识别的类型，也就是说你的代码中有可能有
1.未导入的包.（import java.util.regex.Matcher;）
2.写错的Class Name.
3.未创建却被使用的变量.
7.分组
正则表达式可以用括号进行分组例如：
Pattern p = p.compille(“W(or)(ld!)”);
Matcher m = m.matcher(“Hello,World!”);
其中World整个为第0组，or为第一组，ld!为第二组。
m.group()为m调用group的方法将整组输出。
m.group(1)为m调用group的方法将第一组输出。
m.group(2)为m调用group的方法将第二组输出。
用处：用于分离组内部分（将or单独分离出来）
8.不区分大小写的输出
CASE_INSENSITIVE
例子：Pattern p = p.compile(“java”,Pattern. CASE_INSENSITIVE);
9.StringBuffer buf = new StringBuffer();
New一个StringBuffer.注意大小写。
10.替换字符串
replaceAll(“java”);替换整体不够灵活。
appendReplacement(buf,”java”);appendTail(buf);更灵活，强大。
11. Greedy贪婪的 捡最多的拿，但最后如果不符合还会吐出来
Reluctant不情愿的 捡最少的拿
Possessive独占的 捡最多的拿，但最后如果不符合不会吐出来了。效率高。
Pattern p = Pattern.compile(“.{3,10}[0-9]”);
String s = “aaa5bbbb6”;
Matcher m = p.matcher(s);
12.正则表达式中\\1代表group1与 group2
\\2 有需要了解观看视频“正则表达式补充知识”
未解决的问题：
1.
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class EmailSpider {
public static void main(String[] args) {
try {
BufferedReader br = new BufferedReader(new FileReader("D:\\大学"));
String line = "";
while((line=br.readLine()) != null) {
}l
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
其中readline与readLine有什么不同为什么不能用readline.
能否用br.readline() != null instead of (line=br.readLine()) != null
2.parse用法
二，程序格式
1.变量：本质是内存里面的一小块区域，使用变量名来访问这块区域。每个变量在使用前必须要先申请（声明），然后必须赋值（填充内容）才能使用。
Int i = 100;
float f = 12.3f;
double d1,d2,d3 = 0.123;
String s = “hello”;
注意：String的赋值必须要有双引号“”。
2.内存管理分四块区域：一，code segment 存放代码
二，data segment 存放静态变量，字符串常量
三，stack 局部变量
四，heap new出来的东西
3.java变量分类：
位置：
局部变量：方法或语句块内部定义的变量。
成员变量：方法外部、类里面的定义的变量。（类外部不能有变量的声明）
所属数据类型的划分：
基本数据类型变量：布尔boolean,int,char、short、byte、long,float,double。
引用数据类型：类（class）接口（interface）数组
4.程序格式（比算方法重要）
1，大括号对齐（左大括号所在的行最左边与右大括号对其）
2，遇到左大括号{（之后的内容整体缩进），Tab键
3，程序块之间加空行（方法与方法之间，变量和方法之间，语句块和语句块之间）
4.并排语句之间加空行（for循环的语句之间，还有public class HelloWorld {
HelloWorld与左大括号之间加空格）
5.运算符两侧加空格（“=”for循环内部除外即可以不加空格）
6.{前面应该有空格（public class HelloWorld { ）
7.成对编程（左右大括号同时写）
5.for循环得用；for(int i=0;i<=4;i++) { }
然后for循环的里面出现break，直接跳出for循环执行下一语句。
continue是跳过此步，直接从下一个从头开始。
例子：
public class BreakTest {
public static void main(String args[]) {
System.out.println("循环没有开始");
System.out.println("现在开始测试continue");
for (int i = 0; i < 3; i++) {
System.out.println("开始第" + i + "次for循环");
if (i == 1) {
continue;
}
System.out.println("看看continue后这里执行了吗？");
}
System.out.println("continue测试完毕\n***********************");
System.out.println("现在开始测试break");
for (int i = 0; i < 3; i++) {
System.out.println("开始第" + i + "次for循环");
if (i == 1){
break;
}
System.out.println("看看break后这里执行了吗？");
}
System.out.println("break测试完毕\n***********************");
}
}
上机实验以上程序即可明白
总结：
关于break与continue的区别：break是结束整个循环体，continue是结束单次循环；
6.方法
程序包括一个大类，大类里面有主方法，非主方法，还有变量。成员变量在方法外面，类里面。局部变量在方法里面。
定义：方法：一段完成特定功能的代码片段。
形参：方法被调用时用于接收外界输入的数据*一种形式相当于一个接口
也得事先定义好形参所需传的实参的类型。
实参：调用方法是实际传给方法的数据。按照形参的类型传递。也可不是形参所要求的类型，但必须转化。
返回值：方法在执行完毕后返还给调用它的环境的数据。
返回值类型：事先约定好的返回值的数据类型，如无返回值，必须给出返回值类型是void（空的）。
return语句即可终止方法的运行，也可以指定要返回的数据。无论哪种功能，只要return功能实现，方法结束。
基本数据类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身。
方法定义有返回值，但是可以不用（就是不用System.out.println输出）这个返回值。但必须用return返回，否则报错。注意：System.out.println(i);这句话不可以返回值。
public static int m2(int i) {
return i;
}
想用这个返回值需要在主函数里 定义输出
即： public static void main(String args[]) {
Int a = m2(4);
System.out.println(a);
}
7. java中单引号和双引号有什么区别？
单引号引的数据 是char类型的
双引号引的数据 是String类型的
char定义时用单引号，只能有一个字母，数字。char c='c';数字的单引号代表其ASC码。
而String用双引号，可以是一个，也可能是多个字母，汉字等。就是所谓的字符串。String s="adsaf";
char只是一个基本类型，而String 可以是一个类，可以直接引用。
比如char c='c';不能直接对c调用方法。
String s="abc"; 这时可以调用s.charAt(0);等方法,因为String是类，这是就是对象的调用了
未解决的问题
1. public class TestExample1 {
public static void main(String args[]) {
for(int i=101; i<200; i++ ) {
for(int j=2; j<i; j++) {
if (i % j == 0) {
break;
} else {
System.out.print(i + "");
}
}
}
}
}求101到200以内的质数为什么不对？
三、面向对象
- 对象的“属性”和“方法”分别对应着事物所具有的“静态属性”和“动态属性”。即成员变量和方法。
类：职员
静态属性（成员变量）：姓名，年龄，工资
动态属性（方法）：显示姓名（）显示年龄（）修改姓名（）领取工资
- 对象是类的一个具体实例。
- 本章考虑问题三步骤： 1.问题里所包含的类和对象。
2.每种类每种对象应该具有的属性和方法。
3.类和类之间具备了什么样的关系。（继承关系（一般和特殊）、实现关系、多态）
- 必须首先定义类才能有对象。对象是JAVA核心。对象可以看成是静态属性（成员变量）和动态属性（方法）的封装体。
- Java里面的每一个类就跟一种新的数据类型（int,double）差不多。一样
Dog d = new Dog();
Mouse m = new Mouse();
d.catchMouse(m);
以上为new这个类的一个对象。
对象一般在主方法内定义，类开始就定义好了。
String,System就是一个类
2.java类的定义
用class关键字定义一个类。
类的定义主要有两方面组成：成员变量（private int age = 20）和方法。(public int getAge() {return age;})
类的定义：class 类名 { }。
3.局部变量与成员变量的区别
java里面的变量首先声明，其次再赋值，最后再使用它。
成员变量：定义成员变量时可以对其初始化（即声明+赋值），如果不对其初始化，java使用默认值对其进行初始化。作用范围：整个类体。
局部变量：如果不对其初始化，会报错。必须进行初始化再使用。
成员变量类型 (基本数据类型和引用类型)初始化值
byte、short、int、long 0
char ‘\u0000’
float 0.0F
double 0.0D
boolean false
所有引用类型（例如Mouse） null
4.引用类型：除基本类型（四类八种）之外的变量类型。
所有的引用类型都是指针。
？5.静态变量与非静态变量区别（未理解）
用static修饰的变量叫静态变量。静态变量不需要new出对象引用来调用，它可以直接用类名直接调用。当然用对象引用也能调它，只是不需要。 非静态变量则必须用对象引用进行调用。 静态变量在内存空间中只有一份，也永远只有一份。大家共享。 非静态变量只要new出一个对象引用就会在内存中分配一份空间给它。 并且他两的存放地点不一样，静态变量存放在栈空间。非静态变量存放在堆空间里。
在同个类中，非静态成员方法可以调用静态和非静态的成员变量，而静态的方法只能调用静态的成员变量。 Staitic 修饰的成员变量共享。还有就是成员方法 不可以定义为静态局部变量
静态变量是全局变量，被所有类的实例对象共享。非静态变量是局部变量，不共享的
6.引用：所有的引用类型都是指针。（一小块内存（d）指向一大块内存（堆内存里））
Dog d = new Dog(); d 就是对所new出来的东西的引用（指针）。
new出来的东西存放在堆内存里。
对象是new出来的。位于堆内存里（堆内存空间较大，只有在运行期间才知道new出来的对象的大小故放于较大空间的对内存里）。类的每个成员变量在不同的对象中都有不同的值（除静态变量）而方法只有一份，调用时才分配占用内存空间。
7.对象的创建和使用：
- 必须使用new关键字创建对象。
- 使用对象（引用）.成员变量来引用对象的成员变量。d.furColor()
- 使用对象（引用）.方法（参数列表）来调用对象的方法。
- 同一个类不同new出来的对象有不用的成员变量存储空间。
- 同一类的每个对象共享该类的方法。
8.内存管理分四块区域：一，code segment 存放代码
二，data segment 存放静态变量，字符串常量
三，stack （栈内存） 局部变量
四，heap（堆内存） new出来的东西
理解了内存理解了一切。
9.局部变量
public Cat {
public static void main(String args[]) {
Cat c1 = new Cat();
Cat c2 = new Cat();
Int i = 9;
}
}在上例子中，c1,c2,i都可以看成是局部变量。c1,c2类也是局部变量。方法里面定义的类都可以看做局部变量。
10.构造方法
- 使用new + 构造方法 创建一个新的对象
- 构造函数是定义在Java类中的一个用来初始化对象的函数（方法）。
- 构造函数与类同名且没有返回值(直接类名（）{}不能加void)。
构造方法解答了我心中的疑惑（“new新对象的时候为什么类要加（）”）调用了构造方法。
Cat d = new Cat();
对于构造方法，如果类中未定义类的构造方法，系统会默认构造一个空参数的构造方法（Person() {}）这时只能new 一个无参数的person 比如”Person p = new Person()”如果此时new一个带参数的person就会报错，“Person p = new Person(1,2)”。
如果定义了有参数的构造方法，可以new有参数的对象，不可以new无参数的对象了！ 也就是说：要么，定义构造函数带对象的，那么就只能new一个带参数的类
要么，不定义构造函数，就只能new一个不带参数的类。
11.约定俗成的命名规则
1.类名的首字母大写(Person)
2.变量名和方法名的首字母小写(furColor,int i,catchMouse,scream)
构造方法除外与类同名
3.运用驼峰标识(furColor, catchMouse,HelloWorld)
四、内存解析
基础数据类型的变量就一块内存（栈内存）int i = 4;
引用数据类型的变量有两块内存（栈内存指向堆内存）Dog d = new Dog();
方法调用遵循“值传递”。在JAVA里，凡是引用类型（类、接口、枚举类型、数组）都是传地址，凡是基础类型（8种，如int、long）都是传值。
public static void main(String args[]) {
int day = 9;
BirthDay d1 = new BirthDay(1992,3,4);
对象调用.change2(d1);
test.change1(day);
}
public void change1(int i) {
i = 23 ;
}
public void change2(BirthDay b) {
b = new BirthDay(2001,3,4);
}
在此方法2中传入的参数是Birthday的引用类型。d1属于Birthday的引用，所以可以传d1进来。不能直接传入参数b。这就是传地址（传引用指向同一个对象）
方法1中传入的参数是基本数据类型遵循“值传递”。
1.java修饰符
Java有很修饰符，而且范围有区别 类修饰符 ：public、default、abstract、final、strictfp 接口修饰符 ：public、default、abstract、strictfp 构造器修饰符 ：public、protected、default、private 全局变量修饰符：public、protected、default、private、static、transient、volatile、final 方法修饰符 : public、protected、default、private、abstract、static、final、native、synchronized、strictfp 内部类 ：public、protected、default、private、static、abstract、final 局部变量修饰符：final private 和 public没有对应关系 private可以修饰变量、构造器，方法、内部类；在变量前面加private 表示类的私有属性，只可以在类内部访问使用；
2.内存分析的时候从main方法的第一句开始分析。
3.求距离
double getDistance(Point m) {
return (x-m.x)*（x-m.x）+(y-m.y)*(y-m.y)+(z-m.z)*(z-m.z);
}
未解决的问题
见Test8 change1方法
如何通过调用一个方法来改变一个数值
int i = 4;
public static void chang1(){}
Test9
五.方法的重载
指一个类中可以定义有相同的名字，但参数不同）的多个方法。调用时，会根据不同的参数列表选择对应的方法。只要他们区分的开来，就是构造方法。
参数不同分为：参数个数不同、参数类型不同（int,float）
前提是构成重载的两个方法能够区分。(“返回值不同其他相同”无法区分两个方法;此为“重名现象”会报错)。
构造方法也可以构成重载。（一般重载利用参数个数同，进行参数的设置）
六.对象的创建与使用
- 必须使用new关键字创建对象。
- 使用对象引用.成员变量用来引用对象的成员变量。
- 使用对象引用.方法（参数列表）来调用对象的方法。
- 同一类的每个对象有不同的成员变量存储空间。
- 同一类的每个对象共享该类的方法。
- 非静态方法是针对每个对象进行调用。（无static 的 方法，对于这种方法必须要new个对象利用对象名.才能调用,因为它是依赖于每个对象的属性的，每个对象的成员变量即属性是不同的。【腿长的狗捉兔子】）
2.2月11日所犯错误：
- 类的方法调用，方法必须定义在那个类体里，定义在别的类体里面无法调用自己的方法。
- “return不能输出”，必须调用System.out.println()才能输出；
- “getR()”括号里无参数;解决办法“在设计方法的时候想象类调用这个方法的时候用不用往里面传参数，如果不用例：c.getX，定义getX（）方法的时候括号里不加参数。如果用例：c.setX(double i = 2)，定义set()方法的时候括号里加参数”
详见TestCircle,TestCircle2.
3.this 关键字
- 在类的方法定义中使用的this关键字代表使用该方法的对象的引用。
- 当必须指出当前使用方法的对象是谁时要使用this.
- 有时使用this可以处理方法中成员变量和参数重名的情况。（当无法确定的时候利用就近原则）
- This可以看做是一个变量，他的值是当前对象的引用。
一般出现在方法里，当这个方法还没有调用的时候，this指的是谁并不知道，但是实际当中，如果new一个对象出来，this指的就是当前这个对象，对哪个对象调这个方法，this指的就是谁。
