java基础知识

一、Linux   Java  Java 开发环境

二、Eclipse  JDK JRE JVM  JVM 运行原理：一次编译到处运行

JDK 包含两大部分

1. Java的开发工具（命令） - javac, java, jar, rmic ... 开发工具命令

2. JRE Java运行环境

①. Java 类库（Java API，Java 系统库）

- Java 官方提供的类（程序）

- System String

③. JVM Java 虚拟机 - Java 字节码翻译运行的处理机

③. API 源代码（大部分）

三、变量  声明变量  命名规则  转义字符('\n', ‘\r', '\'', '\",'\')

四、Java中的基本类型 

整数类型 byte  short  int  long   浮点数类型 floatdouble  

char 类型(字符是一个无符号整数, Unicode编码值, 0 ~ 65535)

boolean 布尔类型

五、           Java中的引用类型

                    i.           变量除了基本类型外, 其余都是（"类"类型数组类型声明的变量）

                  ii.           引用类型的值是被引用对象的地址值，通过地址间接引用对象

                 iii.           一个引用变量, 只能存储一个对象的地址

                 iv.           一个对象的地址可以指向多个引用变量

                  v.           引用变量为null，如果调用了其属性\元素\方法将出现空指针异常

 

六、           数据类型转换

       自动类型转换（范围小数据类型可自动转换为范围大，转换期间一般没有损失。）

强制类型转换（大范围的数据类型转换为小范围，有风险，避免溢出现象）

七、           运算

数学运算

同种数据类型参与运算得到同种类型结果，超范围溢出为同类型结果

整数除法是整除，浮点除法是浮点结果

类型不一致，先经过自动类型转换，再运算

byte short char 按照int类型参与运算

取余数运算 %（负对正的余数是负和0，周期计算，判断是否整除）

++自增 --自减（i++;++i;）

运输符号 > < >= <= ==!=

       逻辑运算              运算符（&&与  ||或  !非）  短路逻辑判断现象

       赋值运算              复合赋值运算（包含强制类型转换计算） b += 6;// b = (byte)(b + 6);

       字符串连接运算 

       3元运算

八、           流程控制  

1.顺序

2.分支（if else，switch case default break）

3.循环（while，do ... while，for 循环，break，continue）

 

九、           数组

a)       数组

                    i.           使用长度创建数组,每个元素有默认值）

1.       int byte long short : 0   doublefloat : 0.0

2.       boolean : false         char: 编码为0的字符

3.       引用类型包括String: null

                  ii.           读写(访问)数组的元素（运行异常：超范围访问数组下标越界）

                 iii.           length 属性；

                 iv.           数组的长度在创建后不可改变

 

b)       遍历数组（找出数组最大值，洗牌算法）

c)       复制数组

System.arraycopy(Objectsrc, int srcPos, Object dest, int destPos, int length )

Array.copyOf(类型[ ] original , int newLength)

d)       数组扩容

e)       数组排序（冒泡排序）

Arrays.sort(ary);

f)       引用类型数组：元素都指向具体的对象，每一个数组元素进行“new”运算

g)       二维数组：元素是数组的数组.

 

      

面向对象

一、           面向对象

a)      创建对象 （new 、容器、工厂）

b)      类、对象（又称为实体对象）、属性（又称为成员变量）、方法

c)       语法：class 类名{ public 返回值方法名(参数列表){ 方法体 } }

d)      对象的属性自动初始化，其值为"零"值

e)      数组也是对象，数组变量是引用类型的变量

f)       一个引用变量, 只能存储一个对象的地址，一个对象的地址可以指向多个引用变量

二、           类

1. 普通类

2. 抽象类（abstract class）

a)      不能创建实例，可以定义变量引用具体子类型对象

b)      作为父类被继承，一定要有抽象方法，子类必须实现抽象方法.

      

3. 接口（interface）

       a) 接口是一种特殊抽象类, 只能作为父类型使用，只能定义常量和抽象方法

       b) 子类可以实现(implements)多个接口, 继承多个接口,子类实现全部抽象方法

       c) 接口可以继承接口,

       d) 接口不能直接创建对象, 可以定义变量引用具体子类型对象

       4. 内部类：定义在类内部的类, 称为内部类.

a)      最大的好处是封装, 保护这个内部类, 避免被外部使用.

b)      内部类一般在类的内部使用

c)      可以共享外部类的属性和方法

d)      Outer.this：内部类中包含指向外部类的隐含引用，冲突时使用

5. 匿名内部类：语法简洁, 使用方便, 经常被使用

a)      一种子类型, 必须有父类型，父类型可以是类, 抽象类, 接口

b)      没有名字, 声明类立即创建了对象

c)      只能共享外部方法中final局部变量

d)      实现接口和继承抽象类, 最简洁的办法

e)      编译完成也是一个class文件

 

三、           对象

a)      对象的生命周期:对象的创建到销毁的过程

b)      Java对象生命周期:

                    i.           使用new运算符创建, 对象的属性随着对象在堆中分配.创建过程如下:

1.      Java虚拟机先检查类是否加载, 如果没有加载就加载类信息到方法区.

2.      根据类信息中的属性定义在堆内存中开辟存储空间, 每个属性有默认值

3.      调用构造器, 执行构造器中属性初始化过程,

4.      构造器结束时候, 释放控制器中全部的局部变量.

5.      new运算返回对象的引用.

                  ii.           利用引用操作使用对象 - 使用引用操作对象: 访问对象的属性和方法. - 可以反复更改对象的属性状态.

                 iii.           对象在不被引用时候被垃圾回收器回收 - 当一个对象不再被引用时候, 对象就称为内存垃圾. 内存垃圾在适当时候被垃圾回收器回收.

四、           属性

a)      成员变量：作为类的成员，直接存在于类中。所有类的成员变量通过this来引用。

b)      局部变量：作为方法或语句块的成员而存在，存在于方法的参数列表和方法定义中。

                    i.           成员变量可以被 public，protect，private，static等修饰符修饰而局部变量不能被控制修饰符及 static修饰；两者都可以定义成final型。

                  ii.           成员变量存储在堆，局部变量存储在栈。局 部变量的作用域仅限于定义它的方法，在该方法的外部无法访问它。成员变量的作用域在整个类内部都是可见的，所有成员方法都可以使用它。如果访问权限允许， 还可以在类的外部使用成员变量。

                 iii.           局部变量的生存周期与方法的执行期相同。 当方法执行到定义局部变量的语句时，局部变量被创建；执行到它所在的作用域的最后一条语句时，局部变量被销毁。类的成员变量，如果是实例成员变量，它和对 象的生存期相同。而静态成员变量的生存期是整个程序运行期。

                 iv.           成员变量有默认值，基本类型的默认值为 0，复合类型的默认值为null。（被final修饰且没有static的必须显式赋值），局部变量不会自动赋值，所以局 部变量在定义后先要赋初值，然后才能使用。

                  v.           局部变量可以和成员变量 同名，且在使用时，局部变量具有更高的优先级。

 

 

五、           构造器

1.      构造器

a)      用于封装属性的初始化过程，重复使用创建对象，简化了对象的创建过程

b)      在类中定义，构造器名与类名完全一致，不能定义返回值，也没有void.

c)      对象生存期中构造器只能执行一次.

2.      默认构造器

a)      类一定有构造器

b)      如果源码中不定义构造器, 则编译自动添加默认构造器(一个无参数的构造器)

c)      如果类中定义了构造器, 则Java编译器不再添加默认构造器.

3.      构造器重载：可以声明多个参数不同的构造器

4.      this()：在一个构造器中调用本类其他构造器，实现构造器逻辑复用

                               i.           一定在构造器中第一行使用

5.      this变量：在运行期间代表调用方法的当前这个对象

                               i.           在运行期间代表调用方法的当前这个对象，

                              ii.           对象引用自动传递给this引用，运行结束以后就释放掉.

                             iii.           this引用的类型是当前类型

                            iv.           使用对象属性, 一般省略this.如果对象属性和局部变量名称冲突情况下, 就不能省略了.

                              v.           一般使用this.用于解决对象属性和局部变量的冲突问题

六、           方法

1.方法

用于封装一段特定的逻辑功能，可以反复被调用，可减少代码重复，便于程序的维护，方法中声明的变量和方法的参数是局部变量, 运行期间在栈内存中

方法的要素——（修饰词返回值类型方法名(参数列表){ 方法体 }）

                               i.           修饰词 public private protected static final

                              ii.           返回值  void  return

                             iii.           方法签名：方法名+方法参数类型列表（类中不可存在签名相同的方法）

方法的调用（普通方法、静态方法）

 

2.     方法重载：在类中, 方法名相同, 参数不同(签名不同)

                               i.           调用规则：按参数类型调用，不匹配时优先 "短" 的自动类型转换

3.     方法重写：在子类中, 如果对继承的方法不满意, 则可重写覆盖父类的方法

                               i.           与父类签名一样，返回值要兼容, 修饰词要更加开放, 异常可以更加具体

                              ii.           私有方法, 静态方法, final方法,构造方法(构造器), 属性没有重写

                             iii.           不能继承的方法不能重写

                            iv.           调用规则: 调用运行期间具体对象的方法

 

七、           内存管理

1. Java JVM内存

              分为“堆”、“栈”和“方法区”三个区域，分别用于存储不同的数据。

              堆 -JVM在其内存空间开辟一个称为”堆”的存储空间,存储new关键字创建的对象

              栈 -JVM开辟一个称为”栈”的存储空间,存储运行时在方法中所有局部变量

              方法区 -存放类的信息, 类的各种信息（包括方法）都在方法区存储。

 

       2.  内存泄漏

                    i.           Java的垃圾回收器可以回收堆内存,

                  ii.           当Java程序员操作对象不当时候, Java也会发生内存泄漏.

                 iii.           避免内存泄漏的办法: 对象使用以后,及时将引用对象的引用变量赋值为null

 

八、           面向对象3大特征：封装, 继承, 多态

1.      封装: 保护

a)      隐藏细节降低代码出错的可能性，便于维护；

b)      内部的实现细节改变，只要保证对外的功能定义不变，其他的模块不会被影响

2.      继承(extends):复用

a)      泛化:将多个子类型中的公共部分(属性,方法) 抽取到父类型的过程

                               i.           泛华后, 子类就可以继承父类中属性和方法, 不需要再声明直接使用

b)      super()

                               i.           子类中无super(), Java编译器默认添加，子类一定会调用父类的构造器

                              ii.           默认调用父类的无参数构造器，父类没有无参数构造器, 则编译错误

                             iii.           super只能写在子类构造器的第一行.

c)      super.：在子类中引用父类对象的隐含变量，访问父类中声明的属性和方法

d)       

e)      造型：父类变量引用子类型对象, 称为子类型向上造型为父类型.

                               i.           造型以后, 父类型变量只能访问父类中声明的属性和方法

                              ii.           如果仍然需要访问子类的属性和方法, 必须将父类变量强转为子类型

 

3.      多态：: 动态绑定现象, 引用变量与对象是动态绑定的

                               i.           一个类型的引用在指向不同的对象时会有不同的表现

                              ii.           同样一个对象，造型成不同的类型时，会有不同的功能

a)       Instanceof

                               i.           用于检测引用变量引用的对象的类型兼容性，经常与强制转型配合组成类型安全的强制转型

 

九、           访问控制

1.      package 类的命名空间，对类进行分类, 便于组织和管理

2.      Import导入其他包中的类

i.  package写在Java源文件的第一行.

ii. 包名.类名称为类的全名(全限定名) 可以省略包名.冲突时不能省略

3.       public 公有的,用于修饰类, 属性, 方法，在任何地方都可以访问.

4.       private 私有的, 用于修饰属性, 方法修饰的内容是对内实现的封装

5.       默认不加任何的修饰词.当前包内部可以访问.

6.       static

a)       修饰成员变量

                          i.           不属于对象, 属于类的变量, 存储在方法区, static变量只有“一份”

b)       修饰方法: 静态方法

                          i.           静态方法中没有隐含参数this, 静态方法中不访问当前对象的属性和方法!

                        ii.           调用时直接用类名引用。

                       iii.           其运行结果仅仅与输入的参数有关

c)       静态代码块: 属于类的代码块，在类加载期间执行的代码块，只执行一次

                          i.           用于初始化单 * 例(唯一一份)的资源

7.       final

a)       修饰的变量

                          i.           是一种只能初始化一次, 不能再次更改的变量

                        ii.           static final常量 :必须声明同时初始化，不可被改变

                       iii.           static final 常量会在编译期被替换, 称为编译擦除

 

b)       final声明的类:

                          i.           final类不能再派生子类, 也就是不能作为父类使用

                        ii.           Java API 核心重要类都是final类（String、Integer、Double、Math等）

c)       final 方法

                          i.           使用final关键字修饰的方法, 称为final方法

                        ii.           final方法可以继承，不可以重写