javase知识点

Java基础

 

1.什么是Java？

Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台（即JavaSE, JavaEE, JavaME）的总称。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

2.Java的语言优势

Java语言简单、面向对象、分布式、健壮、安全、体系结构中立、可移植、高性能、解释型、多线程、动态。

3.Java 分类

Java SE(Java Platform  Standard Edition) ：Java平台标准版。主要用于桌面应用程序的开发，是Java技术的核心，提供基础 Java开发工具、执行环境与应用程序接口(API)。 
Java EE(Java Platform  Enterprise Edition):Java平台企业版。主要用于网络程序和企业级应用的开发。
Java ME(Java Platform Mobile Edition) 嵌入式开发（手机手机软件游戏编程、小家电等）  

4.数据类型

基本数据类型：byte、short、int 、 long，float 、double，  char ，boolean
引用数据类型：class 、interface 、array

5..类型的强制转换

Java中的自动类型提升问题。
正向过程：从低字节到高字节可以自动转换。  byte->short->int->long->float->double
逆向过程：从高字节到低字节用强制类型转换。 例：int a = (int)4.562； 注：逆向转换将丢失精度。

6.变量

7.运算符：

算术运算符：
单目：+（取正）   -（取负）  ++（自增1）   --（自减1）
双目：+  -  *   /   %(取余)
三目：a>b?true:false   说明：当a>b的时候，为true(即冒号前面的值)，否则为false;

关系运算符：
==(等于)     !=（不等于）   > (大于)    <（小于）   >=（大于等于）   <=（小于等于）

位运算符，逻辑运算符：
&&（与）：当两边操作数的位数同为1时，结果为1，否则为0。 如 1100 && 1010=1000
||（或）：当两边操作数的位有一边为1时，结果为1，否则为0。如 1100 ||1 010=1110
 ～（非）：0变1，1变0。
 ^（异或）：两边的位不同时，记过为1，否则为0。

赋值运算符
=     +=      -=      *=      /=      %=     &=     |=      <<=        >>=

instanceof 运算符
该运算符为双目运算符，左边的操作元是一个对象，右边是一个类。当左边的对象是右边的类创建的对象时，该运算符运算结果为true，否则为false。

运算符优先级（高----低） [ ]  ( )  ++  --  !  ～  instanceof   * / % + - << >> >>> <> < = > == != &^& & || ? := op= 

 

 

8.条件结构

if(  ){

}

switch( ){

switch( ){

}

 

9.循环结构

while(  ){

}

do{

}while(  )

for(初始部分；条件判断；改变循环变量的值){

}

10.跳转语句

break；跳出loop,执行loop外面的语句
continue；终止本次loop，进入下一次loop

11.数组

数组是一个变量，用于将相同数据类型和数据存储在存储单元中。
数组类型     数组名[  ];   或     数据类型[  ]  数组名；

求数组长数组长度： 数组名.length();
排序：Array.sort(数组名);   //对数组进行升序排列

12.字符串

求字符串长度： 字符串名.length();
字符串比较： 字符串1.equals(字符串2);
常用提取和查询字符串的方法
pubic  int  indexOf( int  a);                 //搜索第一个出现的字符a(或则字符集value)
public  int indexOf( String value);

public   int  lastIndexOf( String  a);      //搜索最后一个出现的字符a(或则字符集value)
public   int  lastIndexOf( String value);

public String subString (int index);       //提取从位置索引开始的字符串部分
public String substring(int begin, int end);        //提取begiin  和end 之间的字符串部分

public String trim();    //返回一个前后不含任何空格的调用字符串的副本.
（数组下标从0开始 ！）

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

配置java环境变量：
JAVA_HOME：配置JDK的目录
CLASSPATH：指定到哪里去找运行时需要用到的类代码（字节码）
PATH：指定可执行程序的位置

Java的垃圾回收：
由一个后台线程gc进行垃圾回收
虚拟机判定内存不够的时候会中断代码的运行，这时候gc才进行垃圾回收
缺点：不能够精确的去回收内存
java.lang.System.gc();建议回收内存，但系统不一定回应，他会先去看内存是否够用，够用则不予理睬，不够用才会去进行垃圾回收
内存中什么算是垃圾：
不在被引用的对象(局部变量，没有指针指向的)

java的安全性：
沙箱机制：只能做沙箱允许的操作
通过下面环节，实现安全
加载有用的类文件，不需要的不加载
校验字节码，查看允许的操作
查看代码和虚拟机的特性是否相符
查看代码是否有破坏性
查看是否有违规操作，如越界
查看类型是否匹配，类型转换是否能正确执行

包(package)：把源文件放在目录下
由于工程的需要，将不同的源文件放在不同的目录下，从而引入了包。
包可以看作就是一个存放java源文件的目录。
在源码中声明一个包名：package p;(只能放在第一行，且最多只能是一行)
如果指定多层包，那么在包名之间我们可以用.作为分隔符：package p1.p2.p3.p4;
用“javac HelloWorld.java –d 绝对路径”，编译后生成的字节码文件就会放在指定的包结构下
执行该程序需要用" java 包名.类名 "
引进包中的某个类：import 包名.类名;

引进包中的所有类：import 包名.*;

标识符：
命名规则：
(1) 由字母、数字、下划线、$组成，不能以数字开头
(2) 大小写敏感
(3) 不得使用java中的关键字和保留字

关键字：都是小写的，jdk1.2多了strictfp(经准浮点型)，关键字 jdk1.4多了assert(断言)关键字，  jdk1.5多了enum(枚举) 关键字
随着学习进度，会慢慢接触到的
true、false、null严格说不应该算关键字，应称其为保留字更合适

习惯：
(1) 标识符要符合语义信息
(2) 包名所有字母小写
(3) 类名每个单词首字母大写，其它小写 //TarenaStudent
(4) 变量和方法：第一个单词小写，从第二个单词开始首字母大写 //tarenaStudent
(5) 常量：所有字母大写，每个单词之间用" _ "连接

Java OOP    Object Oriented Programming，面向对象程序设计

1.面向对象的过程就是抽象的过程，分3步实现：

• 发现类
• 发现类的属性
• 发现类的方法

2.Java中对象的创建和成员的调用方法：

通过构造方法创建对象.。 如：Dog d=new Dog();

通过 对象名 . 属性名调用属性。如：d . name="Lucy"

通过 对象名 . 方法名调用方法。如：d.eat();

 

 

3.类： 类是对某一类事物的具体描述，是抽象的，概念上的定义。

对象：对象是实际存在的该事物的个体，是具体的、现实的。

类包含对象，对象是类的实例。

 

 

4.构造方法（构造函数）：

名字和类名相同，没有返回值类型。在实例化对象是被调用。

 作用：在创建对象是进行一些初始化的操作，比如给成员属性赋初始值....

 

 

5.构造方法和方法的区别：

构造方法  名字和类名相同，无返回值，用new调用；

方法  有自己的名字，用 点 调用

 

6.重载(Overloading)  和  重写(Overriding)区别：

重载：同一个类中，方法名相同，方法的参数列表不同（个数、类型、顺序）

重写：在子父类中，方法名相同，参数列表相同，返回值类型相同（或是其子类）

 

 

7.面向对象的三大特征：封装(Encapsulation)、继承(Inheritance)、多态(Polymorphism)。

封装：

将类的状态信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法对其进行操作和访问。

（好处：隐藏属性；方便加入存储控制语句，限制不合理操作）

 

继承：

通过继承实现代码重用。Java中所有的类都是通过直接或间接继承java.lang.Object类得到的；

继承而得到的类称为子类，被继承的类称为父类。Java只支持单一继承；

子类不能继承父类中访问权限为private的成员变量和方法；

子类可以重写父类的方法，以及命名与父类同名的成员变量。

（好处：实现代码重用）

 

多态：

具有表现多种形态的能力的特征。更专业的说法是，同一个实现接口，使用不同的实例而执行不同的操作。

使用方法：

。继承关系（继承与父类）；

。子类重写父类方法；

。调用父类的方法；

。调用是传入子类实例。

（好处：便于程序的扩展性和维护性。）

 

子类到父类的转换（向上转型）

父类到子类的转换（向下转型）--------类型强转！

 

instanceof运算符：用于判断一个对象是否属于一个类或者实现了一个接口。

基本上包括了Java培训机构所讲的知识点。

对象   instanceof   类/接口

（调用特有的方法要强转，强转是要用instanceof判断）

 

 

8. this 和 super

this关键字：对一个对象的默认引用，在每个实例方法的内部，都有一个this引用变量，指向调用这个方法的对象。

this只能调用实例变量、实例方法、构造方法，不能调用类变量、类方法、局部变量。

 

super关键字：代表当前对象的直接父类对象的默认引用。

子类中通过super关键字访问父类成员(属性、方法、构造方法)。

。super必须在子类中（子类的构造方法或方法中）

。super无法通过private访问父类...

 

 

9.方法修饰符

abstract：

抽象类和抽象方法都通过abstract关键字修饰。

抽象类不能实例化；

抽象方法只有方法体，没有方法实现；

有抽象方法的类一定是抽象类；

如果修饰在父类，则该类为抽象类；

子类必须重写父类所有的抽象方法才能实例化，封装子类还是一个抽象类；

 

final：（开发的程序不希望被拓展，则在类加final）

其修饰的类不能被继承，无子类；

其修饰的方法不能被子类方法重写；

其修饰的变量表示为常量，只能赋值一次。

 

static：

程序加载时马上就会调用；

用static使用属性和方法是不需要实例化，直接调用；

非静态方法不能调用静态方法（数据），静态方法不能调用非静态方法；

 

 

10.访问修饰符

public   -------------任意类可访问，同包或者不同包

private   ------------该类可访问，其他类不能被访问

protected  ---------同包的类中可访问，若不同包，想访问的类必须是被访问的类的子类

default   ------------同包，同类可访问

 

 

11.接口（interface）

I 和类、抽象类是一个层次的概念；

I 中可以定义常量，不能定义变量；

I 中所以方法都是抽象方法；

I 不能实例化，I 中不能有构造方法；

I 直接可以通过extends 实现继承关系，一个I 可以继承多个 I ，但 I 不能继承类；

一个类只能有一个直接父类，但可通过implements实现多个接口；

（extends 必须在 implements 之前）

 

接口有抽象类更好的特性：

。可以被多继承

。设计和实现完全分离

。更加自然的使用多态

。易于搭建程序框架（面向接口编程）

。易于系统的更换

 

 

Java 接口 和C# 接口

	Java Interface	C#  Interface
实现	implements	--
继承	extends	--
静态成员	常量	--
public	可以显式使用	不能显示使用
定义	interface	interface

 

 

 

12.内部类

• Object 类

• String 类   -->>

• StringBuffer类  -->>

• Math 类   -->>

• Runtime 类    -->>

• System 类   -->>

• Date 类  -->>

• DateFormat 类 

• .....

 

 

13.异常

程序中发生的不正常的事件。

异常处理：try   catch   finally   throw   throws

声明异常：throws

抛出异常：throw

 

throw 和throws 区别：

。作用：throw 用于程序员自行产生并抛出异常，throws 用于声明在该方法内抛出了异常；

。使用位置：throw 位于方法体内部，可做单独语句使用，throws 必须跟在方法参数列表后面，不能单独使用；

。内容：throw 抛出一个异常对象，而且只能是一个， throws  后面跟异常类，而且可以跟多个。

 

 

使用多重Catch块时，catch块的排列顺序必须是从子类到父类，最后一个一般是Exception类！

 

常见异常类：

ArithmeticException  算术异常

ArrayIndexOutBoundsException  数组下标越界

NullPointerException    空指针

ClassNotFoundException 不能加载所需要的类

ClassCastException     对象强制类型转换异常

.......