JavaSE

目录

第一章 Java语言概述

1.1 java语言的主要特性

1 简单。 Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用Java。
2 面向对象。 Java语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。
3 分布式。 Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。
4 健壮。 Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。
5 安全。 Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。如：安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查。
6 跨平台。 Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个Java平台的任何系统中运行。
7 性能好。 与那些解释型的高级脚本语言相比，Java的性能还是较优的。
8 多线程。 在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建,目的就是最大化利用CPU。

1.2 Java技术体系平台

Java SE(Java Standard Edition)标准版
支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核心API，此版本以前称为J2SE
Java EE(Java Enterprise Edition)企业版
是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如:Servlet 、Jsp等，主要针对于Web应用程序开发。版本以前称为J2EE
Java ME(Java Micro Edition)小型版
支持Java程序运行在移动终端（手机、PDA）上的平台，对Java API有所精简，并加入了针对移动终端的支持，此版本以前称为J2ME
Java Card
支持一些Java小程序（Applets）运行在小内存设备（如智能卡）上的平台

1.3 Java在各领域中的应用

从Java的应用领域来分，Java语言的应用方向主要表现在以下几个方面：

• 企业级应用： 主要指复杂的大企业的软件系统、各种类型的网站。Java的安全机制以及它的跨平台的优势，使它在分布式系统领域开发中有广泛应用。应用领域包括金融、电信、交通、电子商务等。
• Android平台应用： Android应用程序使用Java语言编写。Android开发水平的高低很大程度上取决于Java语言核心能力是否扎实。
• 移动领域应用： 主要表现在消费和嵌入式领域，是指在各种小型设备上的应用，包括手机、PDA、机顶盒、汽车通信设备等。

1.4 Java语言的特点

• 特点一：面向对象
  
  • 两个基本概念：类、对象
  • 三大特性：封装、继承、多态
• 特点二：健壮性
  
  • 吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制
• 特点三：跨平台性
  
  • 跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write once , Run Anywhere”
  • 原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 (JVM Java Virtual Machine) 即可。由JVM来负责Java程序在该系统中的运行。

1.5 Java两种核心机制

• Java虚拟机（Java Virtal Machine）

  • JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器。
  • 对于不同的平台，有不同的虚拟机。
  • Java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”。

• 垃圾收集机制（Garbage Collection）

  • 不再使用的内存空间应回收—— 垃圾回收。
    
    • 在C/C++等语言中，由程序员负责回收无用内存。
    • Java 语言消除了程序员回收无用内存空间的责任：它提供一种系统级线程跟踪存储空间的分配情况。并在JVM空闲时，检查并释放那些可被释放的存储空间。
  • 垃圾回收在Java程序运行过程中自动进行，程序员无法精确控制和干预。

---

第二章 Java基本语法

• Java中的名称命名规范：
  
  • 包名： 多单词组成时所有字母都小写：xxxyyyzzz
  • 类名、接口名： 多单词组成时，所有单词的首字母大写：XxxYyyZzz
  • 变量名、方法名： 多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
  • 常量名： 所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

变量

变量的概念：

• 内存中的一个存储区域
• 该区域有自己的名称（变量名）和类型（数据类型）
• Java中每个变量必须先声明，后使用
• 该区域的数据可以在同一类型范围内不断变化

变量的分类

• 按数据类型分类
  

• 按声明位置分类
  

  成员变量（属性）和局部变量的区别？

  • 成员变量：
    成员变量定义在类中，在整个类中都可以被访问。
    成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。
    成员变量有默认初始化值。
    成员变量的权限修饰符可以根据需要，选择任意一个

  • 局部变量：
    局部变量只定义在局部范围内，如：方法内，代码块内等。
    局部变量存在于栈内存中。
    作用的范围结束，变量空间会自动释放。
    局部变量没有默认初始化值，每次必须显式初始化。
    局部变量声明时不指定权限修饰符。

整数类型：byte、short、int、long
- Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
- java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
|类型|占用储存空间|表数范围|
|—|—|:—:|
|byte|1字节=8bit|$-128$ ~ $127$|
|short|2字节|$-2^{15}$ ~ $2^{15}-1$|
|int|4字节|$-2^{31}$ ~ $2^{31}-1$|
|long|8字节|$-2^{63}$ ~ $2^{63}-1$|

浮点类型：float、double
与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。
- Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。
- 浮点型常量有两种表示形式：
- 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
- 科学计数法形式:如：5.12e2 512E2 100E-2
|类型|占用储存空间|表数范围|
|—|—|:—:|
|float|4字节|-3.430E38~3.430E38|
|double|8字节|1.798E308 ~ 1.798E308|

字符类型：char

• char 型数据用来表示通常意义上“字符”(2字节)
• 字符型常量的三种表现形式：
  
  • 字符常量是用单引号(‘ ’)括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
  • Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // ‘\n’表示换行符
  • 直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。
• char类型是可以进行运算的。因为它都对应有Unicode码。

转义字符	\b	\n	\r	\t	\”	\’	\\
说明	退格符	换行符	回车符	制表符	双引号	单引号	反斜线

·

布尔类型：boolean
- boolean 类型适于逻辑运算，一般用于程序流程控制：
- if条件控制语句；
- while循环控制语句；
- do-while循环控制语句；
- for循环控制语句；
- boolean类型数据只允许取值true和false，无null。
- 不可以0或非 0 的整数替代false和true，这点和C语言不同

类型转换

• 基本类型转换

  • 自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：
    
  • 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进计算。
  • byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
  • 当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。

• 强制类型转换

  • 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（()），但可能造成精度降低或溢出,格外要注意。
  • 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。
    如： String a = “43”; int i = Integer.parseInt(a);
    boolean类型不可以转换为其它的数据类型。

运算符

• 1 位运算符

运算符	运算	范例	细节
<<	左移	3 << 2 = 12 –> 3*2*2=12	空位补0，被移除的高位丢弃，空缺位补0。
>>	右移	3 >> 1 = 1 –> 3/2=1	被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。
>>>	无符号右移	3 >>> 1 = 1 –> 3/2=1	被移位二进制最高位无论是0或者是1，空缺位都用0补。
&	与运算	6 & 3 = 2	二进制位进行&运算，只有1&1时结果是1，否则是0;
|	或运算	6 | 3 = 7	二进制位进行 | 运算，只有0 | 0时结果是0，否则是1;
^	异或运算	6 ^ 3 = 5	相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1
~	取反	~6 = -7	正数取反，各二进制码按补码各位取反；负数取反，各二进制码按补码各位取反

位运算是直接对二进制进行运算

---

第三章 面向对象编程

面向对象的三大特征

• 封装 (Encapsulation)
• 继承 (Inheritance)
• 多态 (Polymorphism)

匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。
如：new Person().shout();

使用情况:

• 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
• 我们经常将匿名对象作为实参传递给一个方法调用。

内存结构图

==和equals的区别

• 1 == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
• 2 equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
• 3 具体要看自定义类里有没有重写Object的equals方法来判断。
• 4 通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

内部类特性

• Inner class作为类的成员：
  
  • 可以声明为final的
  • 和外部类不同，Inner class可声明为private或protected；
  • Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；
• Inner class作为类：
  
  • 可以声明为abstract类 ，因此可以被其它的内部类继承
    【注意】非static的内部类中的成员不能声明为static的，只有在外部类或static的内部类中才可声明static成员。

设计模式

单例 (Singleton)设计模式

• 1 饿汉式

class Single{
    private Single() {}                       //private的构造器，不能在类的外部创建该类的对象
    private static Single onlyone = new Single();             //私有的，只能在类的内部访问
    public static Single getSingle() {         //getSingle()为static，不用创建对象即可访问
    return onlyone;
    }
}

• 2 懒汉式

class Singleton{
    private Singleton(){}               //将构造器私有化，保证在此类的外部，不能调用本类的构造器
    private static Singleton  instance = null; //要配合static的方法，用static修饰此类的引用
    public static Singleton  getInstance(){                  //设置公共的方法来访问类的实例
        if(instance == null){
            instance = new Singleton();
    }
    return instance;
    }
}

模板方法设计模式(TemplateMethod)

abstract class Template{
    public final void getTime(){
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        System.out.println("执行时间是："+(end - start));
    }
    public abstract void code();
}
class SubTemplate extends Template{
    public void code(){
        for(int i = 0;i<10000;i++){
            System.out.println(i);
        } 
    }
}

代理模式(Proxy)

interface HouseBuilder{
    void build();
}
class ProxyBuilder implements HouseBuilder{
    HouseBuilder target;
    public void build(){
        System.out.println("代理开始");
        target.build();
        System.out.println("代理结束");
    }
    public ProxyBuilder (){
        System.out.println("这是代理类");
        target = new WanKeHouseBuilder();
    }
}
class WanKeHouseBuilder implements HouseBuilder{
    public void build(){
        System.out.println("======");
        System.out.println("======");
        System.out.println("被代理的类");
        System.out.println("万科,比较贵");
        System.out.println("======");
        System.out.println("======");
    }
}

工厂方法(FactoryMethod)

数组和排序

声明方法
数组的元素类型[] 数组名 = new 数组元素类型[长度];

    for (int i = 0; i < 数组名.length; i++) {
        数组名[i] = 每个元素的值;
    }

排序方法
1 冒泡排序

for (int i = 0; i < 数组名.length - 1; i++) {
    for (int j = 0; j < 数组名.length - 1 - i; j++) {
        if (数组名[j] > 数组名[j + 1]) { // 如果是基本数据类型中的数值, 直接可比, 但是如果是对象数组, 用对象 的某属性作为依据
            元素类型 tmp = 数组名[j];
            数组名[j] = 数组名[j + 1];
            数组名[j+1] = tmp;     
        }   
    }
} 

2 选择排序

for (int i = 0; i < 数组名.length - 1; i++) {
    // i是基准位置, 目标是找到包括基准位置在内的右面所有数据中的最小值的下标!!
    int minIndex = i;
    for (int j = i ; j < 数组名.length; j++) {
        if (数组名[j] < 数组名[minIndex]) { // 如果是基本数据类型中的数值, 直接可比, 但是如果是对象数组, 用对象的某属性作为依据
            minIndex = j;       
        }   
    }
    元素类型 tmp = 数组名[i];
    数组名[i] = 数组名[minIndex];
    数组名[minIndex] = tmp;        
}

3 快速排序

void sort(元素类型[] 数组名, int beginIndex, int endIndex) {
    if (beginIndex >= endIndex) {
        return; 
    }
    // 目标是把数组分成 3 部分 小于键值的部分, 键值, 大于键值的部分
    // 取开始的第一个元素就是键值
    元素类型 keyValue= 数组名[beginIndex];
    int keyIndex = beginIndex;
    for (int i = beginIndex + 1; i <= endIndex; i++) {
        if (数组名[i] < keyValue) {
            keyIndex++;
            // 交接小于键值的位置的值和关键下标处的值
            元素类型 tmp = 数组名[i];
            数组名[i] = 数组名[keyIndex];
            数组名[keyIndex] = tmp;            
        }   
    }
    数组名[beginIndex] = 数组名[keyIndex];
    数组名[keyIndex] = keyValue;   

    //小于键值的部分 继续递归
    sort(数组名, beginIndex, keyIndex - 1);
    //大于键值的部分 继续递归
    sort(数组名, keyIndex + 1, endIndex);
}

创建对象的四种方法

public class Dog{   
    public Dog(){  
        super();  
    }      
}  

1、创建对象有什么难的，我们new一个就是的………………对，没错，这只是其中一种

Dog jack = new Dog();  

2、利用class的反射机制，该种方式适用于有无参构造方法的

Class dogClass = Dog.class; //拿到class Dog的 Class实例对象  
Dog rose = (Dog) dogClass.newInstance(); //调用Class的实例方法 newInstance（）创建Dog的实例对象  

Class dogClass = Class.forName("Dog");  
Dog rose = (Dog) dogClass.newInstance();  

3、利用java的对象，可序列化（对象在内存中的分配方式，在本地里保存一份一模一样的看，然后再取出来用，相当于把一个对象的状态完全保存住了,挺牛逼的啊，是不是游游戏里经常这么搞），利用封装类：ObjectOutputStream,ObjectInputStream。
前提：该类必须实现接口Serializable

public class CreateFour implements Serializable {      
    public static void main(String args[]) {  
        CreateFour fCreateFour = new CreateFour();  
        ObjectOutputStream objectStream;  
        try {  
            objectStream = new ObjectOutputStream(new FileOutputStream("res/obj.txt"));  
            objectStream.writeObject(fCreateFour);  

            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("res/obj.txt"));  
            CreateFour cloneFour = (CreateFour) objectInputStream.readObject();  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (ClassNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
    }     
}  

4、利用Object下实例方法clone（）,该类必须实现Cloneable接口，不然会抛出异常CloneNotSupportedException

public class CreateFour implements Cloneable {      
    public static void main(String args[]) {  
        CreateFour f = new CreateFour();  
        try {  
            CreateFour cloneObject = (CreateFour) f.clone();  
        } catch (CloneNotSupportedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
    }  
}  

5、总结
答：好啦，创建对象的4种方式，伙伴们都知道了………… 利用对象流，还是利用clone（），都会开辟新的内存空间，就是在jvm中的堆内存复制一个与源对象相同的新的对象（千万不要以为旧引用与新引用对应的是同一个对象哦）