部分的总结。

    

String类型实际上是由字符数组存储的
所有类型的数据存储都会反映到基本数据类型的存储.
字符串方法：
isEmpty()  判断字符串是否为空
getBytes()  获取字节数组
startsWith 是否已***开始 例: String s1=”1234567a7b7cdefg”; s1.startsWith(“123”);结果:true
是否已***开始  加上偏移量(索引)  例 s1.startsWith(“234”,1);结果:true
endWith  是否已***结束 例: s1.endWith(“fg”); 结果:true
replace()   替换字符 例:s1.replace(“7”,”-”);结果”123456-a-b-cdefg”;
replaceAll()  替换一个区间的字符.  例:replaceAll(“[5-9]”,”#”);结果:”1234###a#b#cdefg”;
contains() 字符串查找.  例:s1.contains(“534”); 结果:false
charAt()   根据索引值获取字符
concat()   把一个字符串拼接到该字符串的结尾
copyValueOf()   把char类型的数组转化为字符串
indexOf()    返回指定字符第一次出现的下标
split()   拆分字符串,按某个规矩
substring()   指定截取(根据索引)  包含前面的不包含后面的
toCharArray()   字符串转化成char数组
toUpperCase()   把小写字母全部转换成大写字母
toLowerCase()   大写转小写
toString()   返回对象本身
trim()   去除字符串前面和后面的空格
valueOf()    把基本数据类型的数组转变成字符串
matches()    判断此字符串是否匹配正则表达式
length()    返回此字符串 的长度

 

开发java程序的步骤:

1.编写源程序 2.编译源程序 3.运行

变量:一个数据存储空间的标识。不同数据存入具有不同内存地址空间，相互独立。

运算符优先级 算数》关系》逻辑》赋值

运算符顺序:算数运算符,关系运算符,逻辑运算符,赋值运算符

 

 

jdk 开发工具包

jvm 运行环境

jre 虚拟机

jdk包含jvm      jvm包含jre

 

计算机组成：

输入设备

中心控制器（cpu）：运算器   控制器 设备处理器

输出设备

 

计算机以二进制存取数据以及程序；

 

 

计算机有软件和硬件组成：

 

系统程序：

应用程序：

 

public class HelloWord{

 

}

public:权限修饰符（公共的）

class：修饰类的关键字

HelloWord：类名

static：静态关键字

void:无返回值

 

字节：

00001001

基本数据类型：

数值型：

byte（1字节8字符）-157-156

short（短整型2字节16字符-32778-32767  

int （整行4字节32字符）-2^32-2^32-1 

long（长整型8字节64字符） -2^63-2^63-1

double（双精点）

float（单精点）

非数值型：boolean（布尔类型）:true,false   char（字符）

char可以跟int互转换

数据类型大的 要加上后缀

 

注释：

单行注释//

多行注释

/*

*

*/

文档注释

/**

*

*/

 

 

运算符：

赋值运算符：= += -=  *=  /=

算术运算符：+ - * / %

关系运算符：>  <  >=  <=  ==  !=    ！（非）

逻辑运算符：&&（逻辑与）  ||(逻辑或)    &(按位与)   |（按位或 ）

条件运算符（三目运算符）：（表达式1？表达式2：表达式3；表达式1=表达式2>表达式3？表达式2：表达式3；）一样

   a>b?a:b;

 

 

选择语句：

if(条件表达式){

代码块

}else{

代码块

}

 

转化为int类型的值；

switch(值){

case  值1：

break;

case  值2：

break;//跳出switch

case  值3：

break;

default:   （否则走default）

break；

}

 

随机数：Math  

获取随机数的方法：random();round（）

 

a++   a--先赋值在运算

++a   --a先运算在赋值

 

 

循环：

有规律的重复执行某一个动作

 

 

满足循环的条件：

变量初始化，满足条件，变量的变化值

 

while(条件表达式){

循环体

}

 

do{

代码块

}while(条件);

 

for(变量初始化;满足条件;变量的变化值){

代码块

}

for(数据类型 变量名：数组名){  //加强版

代码块

}

break：终止

continue:跳出本次循环进行下次循环

 

 

数组：数据类型 数组名[]=new 数据类型[数组长度[length]；

 

存放相同数据类型的一组元素；

         创建数组的方法：

         type arrayName[]=new type[length];

         type[] arrayName=new type[length];

         静态创建数组赋值

         type[] arrayName={1,2,34,45};

         动态赋值：数组的位置从下标为0的位置开始

         arrayName[0]=1;

         arrayName[1]=2;

         获取数组长度：length属性

 

数组：存放相同数据类型的一组元素；

         创建数组的方法：

         type arrayName[]=new type[length];y'y'y'h'hy'y'y'h'h'h'h

         type[] arrayName=new type[length];

         静态创建数组赋值

         type[] arrayName={1,2,34,45};

         动态赋值：数组的位置从下标为0的位置开始

         arrayName[0]=1;

         arrayName[1]=2;

         获取数组长度：length属性

               Arrays.工具类；

 

直接赋值字符串时,并把字符串拼接时,考虑编译期和运行期,如果{值}在编译期可以确定,就使用已有对象,不确定就会创建新的对象.

总结:final 关键字的作用

 

String类型实际上是由字符数组存储的

所有类型的数据存储都会反映到基本数据类型的存储.

字符串方法：

isEmpty()  判断字符串是否为空

getBytes()  获取字节数组

startsWith 是否已***开始 例: String s1=”1234567a7b7cdefg”; s1.startsWith(“123”);结果:true

是否已***开始  加上偏移量(索引)  例 s1.startsWith(“234”,1);结果:true

endWith  是否已***结束 例: s1.endWith(“fg”); 结果:true

replace()   替换字符 例:s1.replace(“7”,”-”);结果”123456-a-b-cdefg”;

replaceAll()  替换一个区间的字符.  例:replaceAll(“[5-9]”,”#”);结果:”1234###a#b#cdefg”;

contains()         字符串查找.  例:s1.contains(“534”); 结果:false

charAt()   根据索引值获取字符

concat()   把一个字符串拼接到该字符串的结尾

copyValueOf()   把char类型的数组转化为字符串

indexOf()    返回指定字符第一次出现的下标

split()   拆分字符串,按某个规矩

substring()   指定截取(根据索引)  包含前面的不包含后面的

toCharArray()   字符串转化成char数组

toUpperCase()   把小写字母全部转换成大写字母

toLowerCase()   大写转小写

toString()   返回对象本身

trim()   去除字符串前面和后面的空格

valueOf()    把基本数据类型的数组转变成字符串

matches()    判断此字符串是否匹配正则表达式

length()    返回此字符串   的长度

         基本数据类型:：byte    short      int     long     char     double      float    boolean

         包装类：Byte     Short      long    Character     Double   Float         Boolean 

引用数据类型： 类   数组    接口

 

装箱与拆箱：

装箱：基本数据类型转化为包装类(引用数据类型）

自动拆箱   手动装箱

拆箱：包装类（引用数据类型）转化为基本数据类型

自动拆箱   手动拆箱

 

1970年1月1日01秒到现在的时间：毫秒 返回值是long

long time=System.currentTimeMllis(）；

 

String Stringbuild Stringbuffer的区别

1.运行速度StringBuilder > StringBuffer > String

String最慢的原因：

　　String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。

 

2. 在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

　　一个StringBuffer对象在字符串缓冲区被多个线程使用时，StringBuffer中很多方法可以带有synchronized关键字，可以保证线程是安全的，StringBuilder的方法则没有该关键字，不能保证线程安全，有可能会出现一些错误的操作。所以如果要进行的操作是多线程的，那么就要使用StringBuffer，但是在单线程的情况下，建议使用速度比较快的StringBuilder。

 

3. String：适用于操作少量的字符串

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

 

权限修饰符   关键字               返回值类型                   方法名    方法体

 public        static                  void（无返回值）          自定义  

 

 static修饰方法直接类名点        

 

return 跳出方法返回结果

 

类是对事物的描述，但不是具体的事物。

 

类就是对一类事物的总称

 

成员变量和局部变量的区别：

作用域不同：

局部变量的作用域仅限于定义它的方法

成员变量的作用域在整个类内部都是可见的

 

初始值不同

java会给成员变量一个初始值

java不会给局部变量赋予初始值

注意:

在同一个方法中，不允许有同名局部变量，在不同的方法中，可以有同名的局部变量

在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级

 

面向对象思想( oop ) :

栈空间:对象的引用:局部变量

堆空间:new出来的东西(包含成员变量)

 

一.  面向对象思想的落地法则一:

1.        设计类,并设计类的成员(成员变量&成员方法)

2.        通过类,未创建类的对象(也称作类的实例化)

3.        通过”对象.属性”或”对象.方法”来调用,完成相应的功能

 

二.     创建的多个对象,彼此各自拥有一套类的属性,当对其中一个对象的属性进行修改时,不会影响到其他对象的属性值.

 

三.     类的属性(成员变量)

 成员变量vs局部变量

相同点:1.遵循变量声明的格式 修饰符 数据类型 变量名 = 初始化值.

2.        都有作用域.

不同点:  1.声明的位置不同,成员变量:声明在类里,方法外

局部变量:声明在方法内,方法的形参部分,代码块内

2.成员变量的修饰符有四个:public private protected 缺省

局部变量没有修饰符,与所在的方法修饰符相同

3.        初始化值:一定会有一个初始化值

成员变量:如果在声明的时候,不显式的赋值,那么不同的数据类型会有不同的默认初始化值.

Byte short int long==>0

Float double ==>0.0

Char==>空格

Boolean==>false

引用变量类型==>null

局部变量:一定要显式的赋值,(局部变量没有默认的初始化值)

4.        二者在内存中存放的位置不同:成员变量存在于堆空间中;局部变量在栈空间中.

 

关于变量的分类:

1)       按照数据类型的不同分为: 基本数据类型(8种)&引用数据类型

2)       按照声明的位置不同:成员变量存在于堆空间中,局部变量存在于栈空间中.

 

四.  类的方法:提供某种功能的实现.

1) 实例: public void eat(){}

Public String getName(){}

Public void setName(String n){}     

   格式:权限修饰符 返回值类型(void无返回值/具体的返回值) 方法名(形参){}

2) 关于返回值类型: void,表明此方法不需要返回值

 有返回值的方法,在方法的最后一定有return + 返回值类型对应的变量;  renturn后不可以声明语句;

记忆:void 和 return 不可同时出现在一个方法中.

3)方法内可以调用本类的其他方法或属性,但是不能在方法内再定义方法!

 

面向   面对以。。。为根据

 

对象:用来描述客观事物的一个实体，由一组属性和方法构成。

类定义了对象将会拥有特征（属性）和行为（方法）

类是对象的类型，对象是类的实例。

如何定义java中的方法

所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

一般情况下，定义一个方法的语句是：

其中：

1。权限修饰符：方法允许被访问的权限范围，可以是 public，protected；private甚至可以省略，

其中，public表示该方法可以被其他任何代码调用

2，返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为void；

如果方法具有返回，则需要指定返回值的类型，并且在方法体中使用return语句返回值

3，方法名：定义的方法名字，必须使用合法的标识符

4，参数列表：传递方法的参数列表，参数可以有多个，多个参数间用逗号隔开，每个参数由参数类型和参数名组成，以空格隔开

 

根据方法是否带参，是否带有返回值，可以将方法分为四类：

 1，无参无返回值的方法：方法不包含参数，且没有返回值

 2，无参带返回值的方法：方法不包含参数，且有返回值    public Sting b(){return"b"}

 3，带参无返回值的方法：方法包含参数，且没有返回值

 4，带参带返回值的方法：方法包含参数，且有返回值

 

形参

就是形式参数  用来接收实际参数的 

实参

就是实际参数

 

封装 private  私有的  只有本身可以用 出来类不能用  

public 公共的，在同一个项目不同的包可以使用

默认default可省略，可以在同一个包里使用

 

方法的重载

1、参数数量不同

2、参数数量相同，参数的类型不同

3.符合设计原则，对原有的修改关闭，对扩展开放

 

static 关键字修饰属性，这个属性属于类与对象无关

1.属性的生命周期从在类开始加载，直到程序结束

2.被称为全局变量

 

satic 关键字修饰方法

1.该方法成为静态方法

2.静态方法不能直接引用该类中的成员变量。（从生命周期角度理解记忆）

3.静态方法不能引用非静态方法。

 

普通代码块 : 节省内存空间

 

1.在方法中定义的代码块，作用是限制作用域（从节省内存空间角度理解记忆）

 

 

构造代码块:       

类中定义的代码块

每次创建对象都会执行一次

执行顺序，构造代码块优先构造方法执行

静态代码块:

用static关键字修饰的代码块

只在对象第一次创建时执行一次

适合在创建对象的时候，先执行一次的业务 

代码块执行顺序:

静态代码块-->构造代码块-->普通代码块

extends  继承

1.继承是面向对象的三大特征之一

2.被继承的类称为父类，继承父类的类称为子类。

继承的限制:

1.java 只允许单继承，一个类只能有一个父类

2.允许多层继承

3.只能继承父类的非 private属性和方法

4.构造方法不能被继承

5.父类中没有默认的构造方法时，子类必须调用super()，并且只能放在第一行。

继承特点：

1.提高代码的维护性

2.提高代码复用性

3.多态的前提

4.增强类与类之间的耦合性

抽象类的用法

abstract

修饰 elass 此类为抽象类，                         

修饰方法： 方法为抽象方法（如果该方法所在的类被继承，则子类必须重写抽象方法）

构造方法 获取里面的内容用的

implements 实现

interface 接口   是与类并行的一个概念

1.接口可以看作是一个特殊的抽象类 是常量和抽象方法的一个集合，不能包含变量、一般的方法

 

2.接口没有构造器，接口不能实例化 ，没有构造器不能创建对象

 

3.接口定义的就是一种功能。可以被类所实现（implements）

 

所有的常量都用 public static final 修饰

 

针对 接口

声明常量：public static  final int i=12;

 抽象方法：所有的都用public abstract修饰

 

声明类用class  声明接口用interface

 

try{

}catch{     

e.printStackTrace();

}

 

1.try代码块里边的代码是容易出现问题的，出现问题的时候通过catch 捕获异常，定位问题 。

 2.运行期捕获异常代码，保证异常代码以后的代码能继续执行。catch捕获异常后必须打印异常信息有助于定位问题。

 

线程关键字 Thread类            Runnable接口

2-1.创建一个类实现，Runnable接口

2-2.实现run（）方法

2-3.实例化创建的类

2-4.以该类的实例化对象为参数，构造Thread实例

2-5.调用start方法，线程进入就绪状态

 

 

什么是反射?

 

Java反射机制是在运行中对任意一个类,能够获取得到这个类的所有的属性和方法,对于任意一个对象,都能够调用他的任意一个方法;这种动态获取类信息以及动态调用类对象方法的功能叫做java语言的反射机制;

什么是javaBean?

JavaBean是一个遵循特定写法的java类,通常具有如下的特点:

1.     这个类必须具有一个无参的构造函数

2.     属性必须私有化

3.     私有化的程序必须通过public类型的方法暴露给其他程序,并且方法的命名也必须遵循一定的命名规范.

使用javaBean的好处: 使用javaBean是为了减少重复的代码,功能区分功明确,提高了代码的维护性.

老师的笔记:

反射是在运行状态,可以动态的获取类的所有的属性以及动态调用任意一个方法，强调的是运行状态。
 
 
       内省(IntroSpector)是Java 语言对 Bean 类属性、事件的一种缺省处理方法。
       　
       JavaBean是一种特殊的类，主要用于传递数据信息，这种类中的方法主要用于访问私有的字段，
       且方法名符合某种命名规则。
 
       如果在两个模块之间传递信息，可以将信息封装进JavaBean中，这种对象称为“值对象”(Value Object)，或“VO”。
       方法比较少。这些信息储存在类的私有变量中，通过setName()、getName()获得。
 
       内省机制是通过反射来实现的，BeanInfo用来暴露一个bean的属性、方法和事件，
       以后我们就可以操纵该JavaBean的属性。

 

List  ArrayList:遍历查询性能高 LinkedList:删除和获取性能高 Vector

Map HashMap  TreeMap  LinkedHashMap:(键值对(key---value))

Set HashSet:无序,元素不可重复 ThreeSet LinkedHashSet

 

重写equals方法,不再比较两个对象的内存地址,而是比较对象的值(根据需求)

---为什么需要hashCode()和equals()方法?

Java集合中判断对象是否相等时使用,判断两个对象是否相等

1.     如果hashCode不相等,则对象不相等

2.     如果hashCode相等,则用equals()方法判断对象是否相等

 

 

Debug:找出程序的问题(性能,错误)