java分为三大类，分别为se,ee,me

SE, EE ,ME

SE:是java的标准版，主要应用于桌面程序的开发

EE:是java的企业版，主要应用于网页的开发

ME:是java的微型版，主要应用于移动设备的开发

谈到java我们不得不提到JVM、JRE、JDK这三者之间的关系

JVM -> JRE -> JDK

jvm是虚拟机，它的主要作用是保证能够将字节码的文件转换为机器识别的语言

jre是java的运行环境，其中包括java常用的类库

jdk中丰富了java会用到的工具

JAVA的执行过程

源文件.java -> 编译器 -> 字节码.class -> 解释器（翻译成计算机识别的机器语言) -> 机器

一、 变量与运算符

1、变量的分类

变量主要分为如上图所示的两大类型

基础类型变量的长度如上图所示

由于每种类型的变量所占用的字节数不同，当涉及到类型转换的问题时，我们需要记住的原则是

字节数少的可以向字节数多的转换

2、变量的存储方式

普通类型变量

在外层作用域定义的变量，可以在内层作用域中访问到。而且每一个变量存储的就是数据本身

引用类型变量

由于引用类型中保存的内容丰富，我们将它保存在对数据中。而我们每次变量存取的内容，实际上是在堆内存中的地址

运算符的顺序

可变参数变量

在方法参数位置上，c就是变量的可变参数列表

public int Sum(int a, int b, int... c){
//其中c可以接受多个变量
}

二、类

谈到类的总结不得不多说两句，本着面向对象的编程思想，万物皆是类。所谓的类就是事物的抽象模板，而通过这些模板生产出来的个体，别称为实例。

1、书写规则

类的书写规则

public class 类名

构造函数的书写规则

public 类名(){}

2、封装

封装是类的三大特性之一，它的功能主要是将数据设置一定的权限，使数据的更加可控

public class Person {
  private String name; //创建私有变量，外界将不能访问
  public setName (String name){
  	this.name = name;   //对私有数据的重置
  }
  public getName (String name){
  	return this.name;    //对私有数据的读取
  }
}

从上述程序，我们简单总结一下封装的流程

• 将数据私有化
• 设置私有数据的getter、setter方法

静态static

所谓的静态修饰符static比较神奇，一旦有static修饰符，就意味着所修饰的内容是class类的一部分了，从类创建的最开始存在，直到不再有对类的操作才消失。

如果被修饰的是静态方法，那它不能访问实例的非静态成员，因为它仅仅是类的一部分。但是成员方法可以访问静态成员

public class Test {
	public String name;
	public Test(String name){
		this.name = name;
	}
	{
		System.out.println("this is oral");
	}//构造代码块
	static {
		System.out.println("this is static oral");
	}//静态代码块
}

静态代码块在创建的一开始就存在，所以仅在创建的时候执行一次

而构造代码块，每次创建新的实例都会执行一次

3、继承

继承就有子类和父类，体现的是类与类的关系。子类承接父类的所有开放特征。

重载和重写

---

重载我们要把握住两个关键点

• 在同一个类中，方法名相同
• 方法中的参数不同

{
	public void say(){
    	System.out.print("i can say");
    }
    public int say(int num){
    	System.out.print("i can say" + num);
        return num;
    }
}

---

重写就是将继承类中的方法重新定义，在重新定义的过程中，我们要知道主要记住以下几点：

• 当返回值为普通类型的时候，我们重写函数的返回值也要一致

• 当返回值为引用类型的时候，返回的类型只能是父类或者是子类

• 访问修饰符要大于父类的范围

参数问题我再看看

父类中
public void show(){
	System.out.print("这是重载")
}
子类中
public void show(int num){
	System.out.print("这是重载" + num)
}

访问修饰符

关于final关键字是紧接访问修饰符的，它的赋值过程主要在1、定义直接初始化 2、构造方法 3、构造代码块

final修饰引用类型的变量时，我们不能修改变量的地址，但是可以修改变量中的内容

继承初始化顺序

父类静态成员-> 子类静态成员 -> new阶段 子类 -> 父类 -> object -> 父类对象构造 -> 子类对象构造

Object

继承自Object的 equals查看的是所指地址是否一样

同时可以通过重写equals比较数值

4、多态

多态简单说，它的意思就是一个对象可以表现出的不同状态，这种特性大大提高了类的灵活度

变量的分析

class Animal 是父类
class Cat 是子类
--------
主函数
Animal one = new Cat()

对于类中非静态变量来说 ： 编译看左边，执行看左边

对于类中函数来说: 编译看左边，执行看右边

导致这种规则的主要原因主要归结于: 函数有重写，而变量没有

多态中的转型

转型存在原因主要是为了弥补，子类函数不能被引用的问题

向上转型

父类引用指向子类

class Animal 是父类
class Cat 是子类
--------
主函数
Animal one = new Cat()
//父类指向了子类

---

向下转型

子类指向了父类

class Animal 是父类
class Cat 是子类
--------
主函数
Cat two = (Cat) one
//子类指向了父类

** 但是同一父类的两个子类是不能互相转化的 **

抽象类

public abstract Animal{
	public abstract void eat(){
    	System.out.print("this is eat function");
    }
}

• 有抽象方法，必有抽象类
• 抽象类不能实例化
• 抽象类的子类必须重写全部抽象方法，否则就必须也是抽象类

接口

接口可以看作是已经定义好的规范、守则。而你需要做的就是根据这个规范，去加以规范其他类。

public interface One{
	public abstract void test();
    public final static int num = 10;
    int num =10;
}

接口中的变量都是静态的常量， 接口中的方法都是抽象的方法

虽然接口被关键字interface所修饰，但是它实际上仍然是一个抽象类

抽象类、接口的应用
抽象类和属性相关
接口和行为相关
public interface door{
//可以报警门的一种特殊行为
	void alarm();
}
public abstact class Door{
//开关门的一般属性
	public abstract open();
    public abstract closed();
}
public class Real extends Door implements door{
}

三、集合

Arraylist

ArrayList<String> one = new ArrayList<String>();
		one.add("one");
		one.add("two");
		one.add("three");
		one.get(2);
		one.set(1, "twotwo");
		System.out.println(one);
		System.out.println(one.size());

杂

string

简单说一下这两种字符串创建方式的存储变化

String one = new String();
String two = "one";
System.out.print(one == two)

• 第一种通过new的方式创建，在new的一瞬间我们在堆中开辟了一块新空间，所以我们每new一次都是一次新空间的开辟

• 第二种我们是将一个常量保存到堆空间中，而two中保存的实际上是变量的引用

== 对于基本数据类型，对比的变量中的值。 对于引用数据类型，对比的是变量中的地址

为什么需要stringbuilder

更好的实现字符拼接，减少内存的开辟。stringbuilder为我们提供了两个好用的APIappend,reverse

但是问题来了，String 和 StringBuilder是两个不同的类，所以我们需要了解互相转换的方法

//string 转为 stringbuilder
String one = "this is string";
StringBuilder s = new StringBuidler(one);


//stringbuilder 转为 string
StringBuilder one = new StringBuilder("haha");
one.toString();

Array类

arrays类为我们提供了两种非常有用的方法，分别是Arrays.sort,Arrays.toString 分别用于数据的排序和转换为字符串

Collection