Java基础一览（会不断补充）

 测试断点操作来检查代码：

基本数据类型：

基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535

自动类型转换：

数据类型转换必须满足如下规则：

• 1. 不能对boolean类型进行类型转换。

• 2. 不能把对象类型转换成不相关类的对象。

• 3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

• 4. 转换过程中可能导致溢出或损失精度，例如：

 

int i =128;   
byte b = (byte)i;

Java语言支持的变量类型有：

• 类变量：独立于方法之外的变量，用 static 修饰。
• 实例变量：独立于方法之外的变量，不过没有 static 修饰。
• 局部变量：类的方法中的变量

• public class Variable{
      static int allClicks=0;    // 类变量
   
      String str="hello world";  // 实例变量
   
      public void method(){
   
          int i =0;  // 局部变量
   
      }
  }

 

习惯：

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

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

基本语法

Java标识符

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

关于Java标识符，有以下几点需要注意：

• 所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始
• 首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字的任何字符组合
• 关键字不能用作标识符
• 标识符是大小写敏感的
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary

编写Java程序时，应注意以下几点：

• 大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
• 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
• 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
• 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
• 主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。

静态

类变量（静态变量）

• 类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。
• 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
• 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
• 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
• 静态变量在程序开始时创建，在程序结束时销毁。
• 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
• 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
• 静态变量可以通过：ClassName.VariableName的方式访问。
• 类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

例如：

import java.io.*;
 
public class Employee {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "开发人员";
    public static void main(String args[]){
    salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

静态变量从属于类
普通变量和方法从属于对象
静态方法不可以使用非静态的方法
普通变量可以使用静态方法

先执行父类的静态初始化块
静态初始化块是初始化类

package
必须要放在第一句

Java.lang 是一个核心包

import--导入----Java中自动导包的快捷键为ctrl+shift+O

面向对象的三大特征：继承；封装；多态

继承
Java的接口可以多继承，Java的类只有单继承
子类继承父类，可以得到父类的所有属性和方法除了父类的构造方法
Java.lang.object是所有类的祖宗类
选中类按ctrl+t可以直接打开继承树查看继承关系
instenceof 运算符
（对象 instenceof 类）

方法的重写(override)（及覆盖）
子类的方法替换父类的方法
重写时要保持方法名和形参列表保持相同
返回值类型子类要小于父类
子类的访问权限要比父类大

object的类中的方法
1.to String
2.equals方法（右击屏幕点击source后直接构造方法）

super位于构造方法的最顶层，在执行构造方式法时会先执行super及父类的方法
若父类为object则为空
程序设计时 会追求高内聚，低耦合

封装
访问控制符
一共有四个：
1.private:只有自己可以使用，表示私有只有自己可以访问
2.default：表示没有修饰符修饰，只有同一个包的类能访问
3.protected：表示可以被同一个包及其他包中的子类访问
4.public：表示可以被该项目中所有的类所访问

 

Java 修饰符：

访问控制修饰符（默认情况下为public）

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

• default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

• public : 对所有类可见。使用对象：类、接口、变量、方法

• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

访问控制和继承

请注意以下方法继承的规则：

• 父类中声明为 public 的方法在子类中也必须为 public。

• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。

• 父类中声明为 private 的方法，不能够被继承。

final 修饰符

final 变量：

final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

final 方法

类中的 final 方法可以被子类继承，但是不能被子类修改。

声明 final 方法的主要目的是防止该方法的内容被修改。

如下所示，使用 final 修饰符声明方法。

public class Test{
    public final void changeName(){
       // 方法体
    }
}

运算符

条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

Java运算符优先级：

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	+ + - ！〜	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>>  <<	左到右
关系	>> = << =	左到右
相等	==  !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	|	左到右
逻辑与	&&	左到右
逻辑或	| |	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = | =	从右到左
逗号	，	左到右

增强for循环和普通for循环的区别

1.增强for循环和iterator遍历的效果是一样的，也就说：增强for循环的内部也就是调用iteratoer实现的(可以查看编译后的文件)。但是增强for循环有些缺点，例如不能在增强循环里动态的删除集合内容，不能获取下标等。

2.ArrayList由于使用数组实现，因此下标明确，最好使用普通循环。

3.而对于 LinkedList 由于获取一个元素，要从头开始向后找，因此建议使用增强for循环，也就是iterator。

多态（polymorphism)
是指同一个方法的调用由于对象不同可能会有不同的行为

多态的三个必要条件
1.继承
2.方法重写
3.父类引用指向子类对象（*****）

final修饰常量，变量，方法，类。

修饰变量：一旦被final修饰变量不可改变，一旦赋了初值就不能被重新赋值
修饰方法：该方法不可被子类重写，但可以被重载
修饰类：修饰的类不可以被继承

 

抽象类：关键字（abstract)
方法：声明加实现
抽象方法必须在抽象类中定义。
抽象类中可以定义普通方法与普通属性
有抽象方法的类一定是抽象类
抽象类不能实例化，及不能用new来实例化抽象类
抽象类可以包含属性/方法/构造方法，但构造方法不能用来new 实例只能用来被子类调用
抽象类只能用来继承。
抽象方法必须被子类实现。

 

接口（interface)

For example:可以将接口看作为公司的规定，而类则是公司的员工，要接受各种
规范的约束，及类可以实现多个接口的功能。

 

可以在包里面直接建一个interface

接口里只有常量和抽象方法

设计和实现分离利于分工
在多人协作时使用

接口可以描述更加抽象的东西
进行更加抽象的定义
一个类可以实现多个接口

通过implements来实现

接口支持多继承

 

回调（CallBack)
多态的应用

 

superinterface
（1. 超接口
l 从直接的超接口（ superinterface ）中继承的成员。
blog.csdn.net|基于18个网页
2.
超级接口
超级接口（superinterface）从本质上来说一定还是一个接口。|评论
zhidao.baidu.com|基于4个网页
3.
超级界面
他没有任何方法，是所有消息的超级界面（superinterface）。
所有消息必须符合这个界面，相应的符合Serializable。）

内部类
作用：
1.内部类提供了更好的封装。只能让外部类“直接访问”。不允许同一个
包中的其他类直接访问。
2.内部类可以直接访问外部类的私有属性，内部类被当做其外部类的成员，
但外部类不能访问内部类的内部属性。

 

面向对象与面向过程
面向对象是用设计的眼光来看待问题（object）
对象就是在内存中的内存块
对象中会放一些变量及方法

类（class)可以看作是对象的模板称为对象的抽象
抽出类似的部分去定义一个类

通过抽象来创建一个类，程序通过类再产生对象
对象（object）（instance）
类中要有属性与方法
属性表示静态特征，及成员变量
方法的定义方式【修饰符】 方法返回值 方法名（）{ }

类中还有构造方法，作用为初始化对象。
创建对象：类名 对象名=new 类名（）；

类名 对象名；//创建一个累的对象

Scanner
获取你输入的数据，用之前需要将 import java.util.Scanner;这个包导入

 

包装类与基本数据类型相对应一共有八种
包装类位于Java.lang包
实例：Integer 对象=new Integer(1000);
将1000包装成为一个对象。
Integer extends number类
Integer.toHexString()：将i变为16进制
Integer.parseIn（）：将字符串转为数字

自动拆箱自动装箱是编译器做的

数组：

 

 

File类
separator：分隔符

 

异常机制，当遇到空指针的异常机制时，加上一个IF条件语句，让异常消失。

异常的处理方法之一
捕获异常（tyr,catch,finally)
try：格式：try{
//语句一；
//语句二；
//语句三；
}catch(Exceptione e){
//语句四；
}finally{
//语句五；
}

异常处理机制使用时一般将子类放前面，父类放后面。

写try—catch语句时的快捷键右键单击选定surround with,然后选Try/catch Block
会自动添加异常处理机制
补充内容：try/catch/finally/return的执行顺序：
1.执行try/catch,给返回值
2.执行 finally
3.return

声明异常throw处理异常的第二个方法
增加一个抛出的声明

关掉try/catch的是read.close

查看层次结构的方式——单击右键找到open Call Hierarchy
快捷键为——ctrl+alt+h即可查看层次结构

 

collection（容器）（也称集合框架）
实例如下：package cn.wk.collection;

import java.awt.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Collection_Demo {

public static void main(String[] args) {

Collection<String> coll01 = new ArrayList<String>();
coll01.add("bbbbbb1");
coll01.add("bbbbbb2");
coll01.add("bbbbbb3");
coll01.add("bbbbbb4");

coll01.size();
System.out.println(coll01);

//迭代器的使用1
Iterator it=coll01.iterator();
for(Iterator it1=coll01.iterator();it1.hasNext();) {
String str=(String) it1.next();
System.out.println(str+" ");
}
System.out.println(coll01.size());
boolean b1=coll01.remove("bbbbbb2");
System.out.println(b1);
System.out.println(coll01);

//添加一个集合
Collection coll02=new ArrayList();

coll02.addAll(coll01);
System.out.println(coll02);
}
}

增强的for循环
代码如下：
for(int m:a){

system.out.println(m);

}

用来遍历数组的元素。

 

IO流

概念：流是一组有顺序的，有起点和终点的字节集合，
是对数据传输的总称或抽象。即数据在两设备间的传输称为流。
流的本质是数据传输，根据数据传输特性将流抽象为各种类，
方便更直观的进行数据操作。
IO流的分类：根据处理数据类型的不同分为：字符流和字节流；
根据数据流向不同分为：输入流和输出流。

 

使用流程

一、
建立联系
File对象，源头
二、
选择流

文件输入流InputStream FileOutStream
三、
操作 write()+flash
四、
释放资源 关闭

详述请见网址：http://www.cnblogs.com/oubo/archive/2012/01/06/2394638.html,

字符流的两个顶层父类
1.Reader ,Writer

这些体系的子类，都以父类为后缀
而且子类名的前缀就是该对象的功能

文字为字符串使用与他关系最近的字符流
例：

//需求：将一些文件储存到硬盘的的一个文件中
记住：如果要操作文字数据，建议优先考虑字符流。
而且要将数据从内存写到硬盘上，要使用字符流中的输出流。Writer

流的规律
转换流：
INPUTSTREAM: 字节到字符的桥梁。解码

OUTPUTSTREAM: 字符到字节的桥梁。编码

流的操作规律：
之所以要弄清楚这个规律，因为流太多，不知道该用哪个

四个明确
1.明确源和目的（汇）
源：input stream reader
目的：output stream writer

2.明确数据是否是纯文本数据。
源：是纯文本数据：reader
否：input stream
目的是：writer
否：output stream

到这里可以明确具体使用哪个体系。

3.明确具体的设备。
源设备：硬盘：file
键盘：system。in
内存：数组
网络：socket流

目的设备：
硬盘：file
控制台：system。out
内存：数组
网络：socket流。

4.是否需要其他额外功能流对象。
1.是否需要高效（缓冲区）
是，就加上buffer。