Java 容器 之前学习了java中从语法到常用类的部分。在编程中有这样一类需求，就是要保存批量的相同数据类型。针对这种需求一般都是使用容器来存储。之前说过Java中的数组，但是数组不能改变长度。Java中提供了另一种存储方式，就是用容器类来处理这种需要动态添加或者删除元素的情况概述Java中最常见的容器有一维和多维。单维容器主要是一个节点上存储一个数据。比如列表和Set。而多维是一个节点有多个数据，例如Map，每个节点上有键和值。单维容器的上层接口是Collection，它根据存储的元素是否为线性又分为两大类 List与Set。它们根据实现不同，List又分为ArrayList和LinkedList；Set下面主要的实现类有TreeSet、HashSet。它们的结构大致如下图:Collection 接口Collection 是单列容器的最上层的抽象接口，它里面定义了所有单列容器都共有的一些方法:boolean add(E e)：向容器中添加元素void clear(): 清空容器boolean contains(Object o): 判断容器中是否存在对应元素boolean isEmpty(): 容器是否为空boolean remove(Object o): 移除指定元素<T> T[] toArray(T[] a) : 转化为指定类型的数组Listlist是Collection 中的一个有序容器，它里面存储的元素都是按照一定顺序排序的，可以使用索引进行遍历。允许元素重复出现，它的实现中有 ArrayList和 LinkedListArrayList 底层是一个可变长度的数组，它具有数组的查询快，增删慢的特点LinkedList 底层是一个链表，它具有链表的增删快而查询慢的特点SetSet集合是Collection下的另一个抽象结构，Set类似于数学概念上的集合，不关心元素的顺序，不能存储重复元素。TreeSet是一颗树，它拥有树形结构的相关特定HashSet: 为了加快查询速度，它的底层是一个hash表和链表。但是从JDK1.8以后，为了进一步加快具有相同hash值的元素的查询，底层改为hash表 + 链表 + 红黑树的结构。相同hash值的元素个数不超过8个的采用链表存储，超过8个之后采用红黑树存储。它的结构类似于下图的结构在存储元素的时候，首先计算它的hash值，根据hash值，在数组中查找，如果没有，则在数组对应位置存储hash值，并在数组对应位置添加元素的节点。如果有，则先判断对应位置是否有相同的元素，如果有则直接抛弃否则在数组对应位置下方的链表或者红黑树中添加节点。从上面的描述看，想要在HashSet中添加元素，需要首先计算hash值，在判断集合中是否存在元素。这样在存储自定义类型的元素的时候，需要保证类能够正确计算hash值以及进行类型的相等性判断。因此要重写类的hashCode和equals 方法。例如下面的例子class Person{ private String name; private int age; Person(){ } Person(String name, int age){ this.name = name; this.age = age; } public int getAge(){ return this.age; } public String getName(){ return this.name; } public void setAge(int age){ this.age = age; } public void setName(String name){ this.name = name; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return age == person.age && Objects.equals(name, person.name); } @Override public int hashCode() { return Objects.hash(this.name, this.age); } }上面说到HashSet是无序的结构，如果我们想要使用hashSet，但是又想它有序，该怎么办？在Set中提供了另一个实现，LinkedHashMap。它的底层是一个Hash表和一个链表，Hash表用来存储真正的数据，而链表用来存储元素的顺序，这样就结合了二者的优先。MapMap是一个双列的容器，一个节点存储了两个值，一个是元素的键，另一个是值。其中Key 和 Value既可以是相同类型的值，也可以是不同类型的值。Key和Value是一一对应的关系。一个key只能对应一个值，但是多个key可以指向同一个value，有点像数学中函数的自变量和值的关系。Map常用的实现类有: HashMap和LinkedHashMap。常用的方法有:void clear(): 清空集合boolean containsKey(Object key): map中是否包含对应的键V get(Object key): 根据键返回对应的值V put(K key, V value): 添加键值对boolean isEmpty(): 集合是否为空int size(): 包含键值对的个数遍历针对列表类型的，元素顺序固定，我们可以使用循环依据索引进行遍历，比如for(int i = 0; i < list.size(); i++){ String s = list.get(i); }而对于Set这种不关心元素的顺序的集合来说，不能再使用索引了。针对单列集合，有一个迭代器接口，使用迭代器可以实现遍历迭代器迭代器可以理解为指向集合中某一个元素的指针。使用迭代器可以操作元素本身，也可以根据当前元素寻找到下一个元素，它的常用方法有:boolean hasNext() : 当前迭代器指向的位置是否有下一个元素E next(): 获取下一个元素并返回。调用这个方法后，迭代器指向的位置发生改变使用迭代器的一般步骤如下:使用集合的 iterator() 返回一个迭代器循环调用迭代器的 hasNext方法，判断集合中是否还有元素需要遍历使用 next方法，找到迭代器指向的下一个元素//假设set是一个 HashSet<String>集合 Iterator<String> it = set.iterator(); while(it.hasNext()){ Stirng s = it.next(); }Map遍历索引和迭代器的方式只能遍历单列集合，像Map这样的多列集合不能使用上述方式，它有额外的方法，主要有两种方式获取key的一个集合，遍历key集合并通过get方法获取value获取键值对组成的一个集合，遍历这个新集合来得到键值对的值针对第一种方法，Map中有一个 keySet() 方法。这个方法会获取到所有的key值并保存将这些值保存为一个新的Set返回，我们只要遍历这个Set并调用 Map的get方法即可获取到对应的Value, 例如:// 假设map 是一个 HashMap<String, String> 集合 Set<String> kSet = map.keySet(); Iterator<String> key = kSet.iterator(); while(it.hasNext()){ String key = it.next(); String value = map.get(key); }针对第二种方法，可以先调用 Map的 entrySet() 获取一个Entry结构的Set集合。Entry 中保存了一个键和它对应的值。使用结构中的 getKey() 和 getValue() 分别获取key和value。这个结构是定义在Map中的内部类，因此在使用的时候需要使用Map这个类名调用// 假设map 是一个 HashMap<String, String> 集合 Set<Map.Entry<String,String>> entry = map.entrySet(); Iterator<Map.Entry<String, String>> it = entry.iterator(); while(it.hasNext()){ Map.Entry<String, String> me = it.next(); String key = me.getKey(); String value = me.getValue(); }for each 循环在上述遍历的代码中，不管是使用for或者while都显得比较麻烦，我们能像 Python 等脚本语言那样，直接在 for 中使用迭代吗？从JDK1.5 以后引入了for each写法，使Java能够直接使用for迭代，而不用手工使用迭代器来进行迭代。for (T t: set); 上述是它的简单写法。例如我们对遍历Set的写法进行简化//假设set是一个 HashSet<String>集合 for(String s: set){ //TODO:do some thing }我们说使用 for each写法主要是为了简化迭代的写法，它在底层仍然采用的是迭代器的方式来遍历，针对向Map这样无法直接使用迭代的结构来说，自然无法使用这种简化的写法，针对Map来说需要使用上述的两种遍历方式中的一种，先转化为可迭代的结构，然后使用for each循环// 假设map 是一个 HashMap<String, String> 集合 Set<Map.Entry<String, String>> set = map.entrySet(); for(Map.Entry<String, String> entry: set){ String key = entry.getKey(); String value = entry.getValue(); System.out.println(key + "-->" + value); }泛型在上述的集合中，我们已经使用了泛型。泛型与C++ 中的模板基本类似，都是为了重复使用代码而产生的一种语法。由于这些集合在创建，增删改查上代码基本类似，只是事先不知道要存储的数据的类型。如果没有泛型，我们需要将所有类型对应的这些结构的代码都重复写一遍。有了泛型我们就能更加专注于算法的实现，而不用考虑具体的数据类型。在定义泛型的时候，只需要使用 <>中包含表示泛型的字母即可。常见的泛型有:T 表示TypeE 表示 Element<> 中可以使用任意标识符来表示泛型，只要符合Java的命名规则即可。使用 T 或者 E 只是为了方便而已，比如下面的例子public static <Element> void print(Element e){ System.out.println(e); }当然也可以使用Object 对象来实现泛型的重用代码的功效，在对元素进行操作的时候主要使用java的多态来实现。但是使用多态的一个缺点是无法使用元素对象的特有方法。泛型的使用泛型可以在类、接口、方法中使用在定义类时定义的泛型可以在类的任意位置使用class DataCollection<T>{ private T data; public T getData(){ return this.data; } public void SetData(T data){ this.data = data; } }在定义类的时候定义的泛型在创建对象的时候指定具体的类型.也可以在定义接口的时候定义泛型public interface DataCollection<T>{ public abstract T getData(); public abstract void setData(T data); }定义接口时定义的泛型可以在定义实现类的时候指定泛型，或者在创建实现类的对象时指定泛型public class StringDataCollectionImpl implements DataCollection<String>{ private String data; public String getData(){ return this.data; } public void SetData(String data){ this.data = data; } } public interface DataCollection<T> implements DataCollection<T>{ private T data; public T getData(){ return this.data; } public void SetData(T data){ this.data = data; } }除了在定义类和接口时使用外，还可以在定义方法的时候使用，针对这种情况，不需要显示的指定使用哪种类型，由于接收返回数据和传入参数的时候已经知道了public static <Element> Element print(Element e){ System.out.println(e); return e; } String s = print("hello world");泛型的通配符在使用通配符的时候可能有这样的需求：我想要使用泛型，但是不希望它传入任意类型的值，我只想要处理继承自某一个类的类型，就比如说我只想保存那些实现了某个接口的类。我们当然可以将数据类型定义为某个接口，但是由于多态的这一个缺陷，实现起来总不是那么完美。这个时候可以使用泛型的通配符。泛型中使用 ? 作为统配符。在通配符中可以使用 super 或者 extends 表示泛型必须是某个类型的父类或者是某个类型的实现类class Fruit{ } class Apple extends Fruit{ } class Bananal extends Fruit{ } static void putFruit(<? extends Fruit> data){ }上述代码中 putFruit 函数中只允许 传递 Fruit 类的子类或者它本身作为参数。当然也可以使用 <? super T> 表示只能取 T类型的父类或者T类型本身。

Java 常用类 之前将Java的大部分语法都回顾完了，后面添加一些常见的操作，基础语法就结束了。至于在这里再次提到常用类是由于有一部分体现在使用它的继承类或者接口之类的。这些需要有面向对象编程的基础Object类Object类是所有类的基类，只要定义了类，即使没有显式的声明继承自Object类，也会从该类继承。这个类没有什么是需要显式调用的，很多东西都需要重写类的方法来达到相关效果，比如常用的两个方法:String toString() : 将类转化为字符串。一般来说直接打印新定义的类都会打印出对象的地址值，如果需要打印里面的相关值，需要重写toString方法boolean equals(Object obj): 一般来说，== 比较的是对象的地址值，而针对字符串或者其他对象可能需要根据别的值来比较是否相等，这个时候需要重写这个方法。protected Object clone(): 在C++中如果直接使用内存拷贝来拷贝对象的话，如果对象中有指针变量，可能会导致一系列的问题，这种拷贝方法叫做浅拷贝。这个方法用来执行深度拷贝操作。public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }上述代码是Object类的 toString 方法，从代码上看，默认会调用对象的hashCode 方法获取hash值，并转化为字符串。时间操作Date 类Date 类用来处理时间，它能精确到毫秒Date(): 获取当前时刻的Unix时间戳Date(long date): 根据一个时间戳初始化一个对象long getTime(): 获取当前对象对应的时间戳这个方法目前只是用来进行这些操作，后续其他时间的格式化，获取对应的年、月、日操作在后续的JDK版本都用另外的类来进行SimpleDateFormat 类上面提到，Date类只用来进行时间戳相关转化的操作，而具体与时间相关的操作都用这个类来进行。该类继承自 DataFormat 类， DataFormat是一个抽象类。SimpleDateFormat() : 使用默认的模式来格式化Date类SimpleDateFormat(String pattern): 按照指定格式来格式化Date类SimpleDateFormat(String pattern, Locale locale): 构造一个 SimpleDateFormat使用给定的模式和给定的区域设置的默认日期格式符号模式类似于格式化字符串，与常见语言的格式化时间的方式类似。String format(Date date): 按照构造时提供的模式来将传入的date 对象格式化为字符串Date parse(String source): 从给定字符串的开始解析文本以生成日期Calendar 类上述两个与时间相关的类已经解决了时间的获取以及格式化输出的操作。但是关于时间还需要进行年、月、日相关的操作。比如加一年、减一个月等等。跟具体年月相关的操作使用 Calendar类。这个类也是一个抽象类，但是可以使用它的相关静态方法来创建对象static Calendar getInstance(): 使用默认时区和区域设置获取日历。static Calendar getInstance(Locale aLocale): 使用默认时区和指定的区域设置获取日历。常见的方法如下:int get(int field): 返回指定字段的日历值void set(int year, int month, int date, int hourOfDay, int minute, int second): 设置字段中的值 YEAR ， MONTH ， DAY_OF_MONTH ， HOUR_OF_DAY ， MINUTE和 SECONDabstract void add(int field, int amount): 根据日历的规则，将指定的时间量添加或减去给定的日历字段Date getTime(): 根据日历对象返回一个对应的Date类void setTime(Date date): 将Date类转化为日历类这些get和set方法有的需要一个值表示需要修改日历中的哪个值。比如 YEAR表示年、MONTH表示月、DAY_OF_MONTH表示月中的天数、HOUR_OF_DAY表示小时等等从这3个类的相关操作来说，Date类作为沟通其他两个类的桥梁，常见的策略是: DateFormat -->Date -->Calender 或者 Calender-->Date-->DateFormat下面是一个简单的例子DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date date = df.parse("2018-10-1 12:12:12"); Calendar c = Calendar.getInstance(); c.set(Calendar.YEAR, 2019); date = c.getTime(); System.out.println("Time:" + df.format(date));System 类这个类用于获取系统相关的内容，里面都是一些静态方法。常用的方法有:static long currentTimeMillis(): 返回当前系统时间，以毫秒为单位static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length): 数组复制方法StringBuilder 类我们说String方法中的字符不能修改，如果要修改，必须重新分配一个String，并舍弃原来的String方法。当String操作过多，频繁的分配回收，影响程序效率。StringBuilder类与String相比，可以修改里面的字符值。相比String来说效率更高StringBuilder(): 构造一个能容纳16个字符的字符容器StringBuilder(int capacity) ：构造一个容纳指定字符的容器StringBuilder(String str): 构造一个初始化为指定字符串内容的字符串构建器。append方法：它有一系列的重载方法。往字符容器中添加指定的内容toString(): 转化为String 对象包装类Java中针对 普通类型都有一个对应的类，封装了一系列的操作，比如int 类的包装类是 Integer, double 类的是 Double等等。一般来说，将对应的基本类型转化为包装类的过程称为装箱；将包装类转化为基本类型的过程称为拆箱，从JDK1.5之后支持自动装箱和自动拆箱,比如Double d = 1.5; int i = Integer(10); int i1 = Integer("10");

Java 匿名对象与内部类 一般在编写代码时可能会遇到这样的场景——在某些时候，我需要定义并某个类，但是只会使用这一次，或者是某个类对象只会使用一次，为它们专门取名可能会显的很麻烦。为了应对这种情况，Java中允许使用匿名对象和匿名内部类的方式来解决这个矛盾匿名对象普通的类对象在使用时会定义一个类类型的变量，用来保存new出来的类所在的地址。而匿名类取消掉了这个变量，这个地址由编译器来处理，并且在new出来之后，它占用的内存会有JVM自动回收掉。后续无法再使用了。例如public class Student{ public void classBegin(){ System.out.println("good morning teacher!"); } } new Student().classBegin();匿名对象最常用的方式是作为函数的参数，比如上述的打印语句 "good morning teacher!" 它就是一个匿名对象，由于字符串是以对象的形式存储的，所以这里实际上就是一个没有使用对象引用的匿名对象。当然也可以将匿名对象作为函数的返回值。内部类内部类的种类：成员内部类、静态内部类、局部内部类、匿名内部类成员内部类java中允许在一个类中定义另一个类。例如public class Car{ public class Engine{ } }上述例子在Car这个类中定义了一个Engine类，那么Car就是外部类，而Engine就是内部类。使用内部类需要注意：外部类是包含内部类的，所以内部类可以看到外部类的所有属性和方法，包括private方法。但是反过来则不行；使用内部类主要有两种方式：在外部类中使用内部类的成员（间接使用）。这种方法一般是在外部类的方法中创建内部类的对象，并调用对象的方法直接使用：根据上面的定义，可以这样使用 `Car.Engine eng = new Car().new Engine()比如下面的例子public class Car{ public class Engine{ public void start(){ System.out.println("引擎启动"); } } //间接调用 public void start(){ System.out.println("打火"); new Engine().start(); } public static void main(String[] args){ new Car().start(); //直接调用 Car.Engine engine = new Car().new Engine(); engine.start(); } }当外部类和内部类的成员发生命名冲突的时候在内部类中可以使用 外部类.this.成员变量 来访问外部类的成员比如说public class Car{ public String type = "奥迪"; public class Engine{ public String type = "奥迪引擎"; public void start(){ System.out.println("引擎启动"); } public void carType(){ System.out.println(Car.this.type); } } //间接调用 public void start(){ System.out.println("打火"); new Engine().start(); } public static void main(String[] args){ Car car = new Car(); //直接调用 Car.Engine engine = new Car().new Engine(); engine.start(); engine.carType(); } }局部内部类内部类不光可以直接定义在外部类中作为成员内部类，也可以定义在方法中，作为局部内部类局部内部类也叫区域内嵌类，局部内部类与成员内部类类似，不过，区域内嵌类是定义在一个方法中的内嵌类主要特定有：局部内部类只能在对应方法中访问，在方法外无效不能使用private，protected，public修饰符。不能包含静态成员局部内部类如果想要访问方法中的局部变量时，局部变量必须是常量。因为局部变量时分配在栈中，而局部内部类是分配在堆中的，有可能出现这样的情况，外部类的方法执行完了，内存被回收了，但是局部内部类可能还在，所以在访问局部变量时，做了一个拷贝将局部变量拷贝到局部内部类所在的堆中。为了保证数据的完整性，所以这里被拷贝的变量不允许再做修改。public class carShow(){ public void showCar(){ final float price = 10000000f; final String type = "奔驰"; class Car(){ public void show(){ System.out.println("这个车是" + type + ",售价:" + price); } } } }静态内部类内部类如果使用static声明，则此内部类就称为静态内部类。它可以通过 外部类 . 内部类 的方式来访问。由于静态内部类是与对象无关的，在使用静态类的成员时是不需要创建对象的。所以如果想要在静态内部类中来访问外部类的成员变量，必须通过外部类的对象实例来访问。public class Company { String companyNam; static String country; static class Clear{ String name; public Clear() { } public Clear(String name) { super(); this.name = name; } public void work(String name){ String na = new Company().companyNam="联想"; country="中国"; System.out.println(name+"为"+na+"打扫卫生，该公司属于"+country); } } }匿名内部类如果一个内部类在整个操作中只使用一次的话，就可以定义为匿名内部类。匿名内部类也就是没有名字的内部类，这是java为了方便我们编写程序而设计的一个机制，因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适。匿名内部类，一般都伴随着接口一起使用比如public interface USB{ public abstract void open(); public abstract void close(); } public class Demo{ public static void main(String[] args){ USB usb = new USB(){ public void open(){} public void close(){} } usb.open(); usb.close(); //使用匿名内部类的匿名对象的方式 USB usb = new USB(){ public void open(){} public void close(){} }.open(); } }在Demo这个类的main方法中创建了一个局部的内部类，这个内部类没有名字，也就是创建了一个匿名内部类。

Java 接口与多态 上一篇说了Java面向对象中的继承关系，在继承中说到：调用对象中的成员变量时，根据引用类型来决定调用谁，而调用成员方法时由于多态的存在，具体调用谁的方法需要根据new出来的对象决定，这篇主要描述的是Java中的多态以及利用多态形成的接口多态当时在学习C++时，要使用多态需要定义函数为virtual，也就是虚函数。类中存在虚函数时，对象会有一个虚函数表的头指针，虚函数表会存储虚函数的地址，在使用父类的指针或者引用来调用方法时会根据虚函数表中的函数地址来调用函数，会形成多态。当时学习C++时对多态有一个非常精炼的定义：基类的指针指向不同的派生类，其行为不同。这里行为不同指的是调用同一个虚函数时，会调用不同的派生类函数。这里我们说形成多态的几个基本条件：1)指针或者引用类型是基类；2）需要指向派生类；3）调用的函数必须是基类重写的函数。public class Parent{ public void sayHelllo(){ System.out.println("Hello Parent"); } public void sayHello(String name){ System.out.println("Hello" + name); } } public class Child extends Parent{ public void sayHello(){ System.out.println("Hello Child"); } }根据上述的继承关系，我们来看下面几个实例代码，分析一下哪些是多态Parent obj = new Child(); obj.sayHello();该实例构成了多态，它满足了多态的三个条件：Parent 类型的 obj 引用指向了 new 出来的Child子类、并且调用了二者共有的方法。Parent obj = new Child(); obj.sayHello("Tom");这个例子没有构成多态，虽然它满足基类的引用指向派生类，但是它调用了父类特有的方法。Parent obj = new Parent(); obj.sayHello();这个例子也不满足多态，它使用父类的引用指向了父类，这里就是一个正常的类方法调用,它会调用父类的方法Child obj = new Child(); obj.sayHello();这个例子也不满足多态，它使用子类的引用指向了子类，这里就是一个正常的类方法调用,它会调用子类的方法那么多态有什么好处呢？引入多态实质上也是为了避免重复的代码，而且程序更具有扩展性，我们通过println函数来说明这个问题。public void println(Object x) { String s = String.valueOf(x); synchronized (this) { print(s); newLine(); } } //Class String public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); }函数println实现了一个传入Object的重载，该函数调用了String类的静态方法 valueOf, 进一步跟到String类中发现，该方法只是调用了类的 toString 方法，传入的obj可以是任意继承Object的类(在Java中只要是对象就一定是继承自Object),只要类重写了 toString 方法就可以直接打印。这样一个函数就实现了重用，相比于需要后来的人额外重载println函数来说，要方便很多。类类型转化上面的println 函数，它需要传入的是Object类的引用，但是在调用该方法时，从来都没有进行过类型转化，都是直接传的，这里是需要进行类型转化的，在由子类转到父类的时候，Java进行了隐式类型转化。大转小一定是安全的（这里的大转小是对象的内存包含关系），子类一定可以包含父类的成员，所以即使转化为父类也不存在问题。而父类引用指向的内存不一定就是包含了子类成员，所以小转大不安全。为什么要进行小转大呢？虽然多态给了我们很大的方便，但是多态最大的问题就是父类引用无法看到子类的成员，也就是无法使用子类中的成员。这个时候如果要使用子类的成员就必须进行小转大的操作。之前说过小转大不安全，由于父类可能有多个实现类，我们无法确定传进来的参数就是我们需要的子类的对象，所以java引入了一个关键字 instanceof 来判断是否可以进行安全的转化，只要传进来的对象引用是目标类的对象或者父类对象它就会返回true，比如下面的例子Object obj = "hello" System.out.println(obj instanceof String); //true System.out.println(obj instanceof Object); //true System.out.println(obj instanceof StringBuffer); //false System.out.println(obj instanceof CharSequence); //true抽象方法和抽象类我们说有了多态可以使代码重用性更高。但是某些时候我们针对几个有共性的类，抽象出了更高层面的基类，但是发现基类虽然有一些共性的内容，但是有些共有的方法不知道如何实现，比如说教科书上经常举例的动物类，由于不知道具体的动物是什么，所以也无法判断该动物是食草还是食肉。所以一般将动物的 eat 定义为抽象方法，拥有抽象方法的类一定必须是抽象基类。抽象方法是不需要写实现的方法，它只需提供一个函数的原型。而抽象类不能创建实例，必须有派生类重写抽象方法。为什么抽象类不能创建对象呢？对象调用方法本质上是根据函数表找到函数对应代码所在的内存地址，而抽象方法是未实现的方法，自然就无法给出方法的地址了，如果创建了对象，而我的对象又想调用这个抽象方法那不就冲突了吗。所以规定无法实例化抽象类。抽象方法的定义使用关键字 abstract，例如public abstract class Life{ public abstract void happy(); } public class Cat{ public void happy(){ System.out.println("猫吃鱼"); } } public class Cat{ public void happy(){ System.out.println("狗吃肉"); } } public class Altman{ public void happy(){ System.out.println("奥特曼打小怪兽"); } }上面定义了一个抽象类Life 代表世间的生物，你要问生物的幸福是什么，可能没有人给你答案，不同的生物有不同的回答，但是具体到同一种生物，可能就有答案了，这里简单的给出了答案：幸福就是猫吃鱼狗吃肉奥特曼爱打小怪兽。使用抽象类需要注意下面几点:不能直接创建抽象类的对象，必须使用实现类来创建对象实现类必须实现抽象类的所有抽象方法，否则该实现类也必须是抽象类抽象类可以有自己的构造方法，该方法仅供子类构造时使用抽象类可以没有抽象方法，但是有抽象方法的一定要是抽象类接口接口就是一套公共的规范标准，只要符合标准就能通用，比如说USB接口，只要一个设备使用了USB接口，那么我的电脑不管你的设备是什么，插上就应该能用。在代码中接口就是多个类的公共规范。Java中接口也是一个引用类型。接口与抽象类非常相似，同样不能创建对象，必须创建实现类的方法。但是接口与抽象类还是有一些不同的。 抽象类也是一个类，它是从底层类中抽象出来的更高层级的类，但是接口一般用来联系多个类，是多个类需要实现的一个共同的标准。是从顶层一层层扩展出来的。接口的一个常见的使用场景就是回调，比如说常见的窗口消息处理函数。这个场景C++中一般使用函数指针，而Java中主要使用接口。接口使用关键字 interface 来定义, 比如public interface USB{ public final String deviceType = "USB"; public abstract void open(); public abstract void close(); }接口中常见的一个成员是抽象方法，抽象方法也是由实现类来实现，注意事项也与之前的抽象类相同。除了有抽象方法，接口中也可以有常量。接口中的抽象方法是没有方法体的，它需要实现类来实现，所以实现类与接口中发生重写现象时会调用实现类，那么常量呢?public class Mouse implements USB{ public final String deviceType = "鼠标"; public void open(){ } public void close(){ } } public class Demo{ public static void main(String[] args){ USB usb = new Mouse(); System.out.println(usb.deviceType); } }常量的调用遵循之前说的重载中的属性成员调用的方式。使用的是什么类型的引用，调用哪个类型中的成员。与抽象类中另一个重要的不同是，接口运行多继承，那么在接口的多继承中是否会出现冲突的问题呢public interface Storage{ public final String deviceType = "存储设备"; public abstract void write(); public abstract void read(); } public class MobileHardDisk implements USB, Storage{ public void open(){ } public void close(){ } public void write(){ } public void read(){ } } public class Demo{ public static void main(String[] args){ MobileHardDisk mhd = new MobileHardDisk(); System.out.println(mhd.deviceType); } }编译上述代码时会发现报错了，提示 USB 中的变量 deviceType 和 Storage 中的变量 deviceType 都匹配 ，也就是说Java中仍然没有完全避免冲突问题。接口中的默认方法有的时候可能会出现这样的情景，当项目完成后，可能客户需求有变，导致接口中可能会添加一个方法，如果使用抽象方法，那么接口所有的实现类都得重复实现某个方法，比如说上述的代码中，USB接口需要添加一个方法通知PC设备我这是什么类型的USB设备，以便操作系统匹配对应的驱动。那么可能USB的实现类都需要添加一个，这样可能会引入大量重复代码，针对这个问题，从Java 8开始引入了默认方法。默认方法为了解决接口升级的问题，接口中新增默认方法时，不用修改之前的实现类。默认方法的使用如下:public interface USB{ public final String deviceType = "USB"; public abstract void open(); public abstract void close(); public default String getType(){ return this.deviceType; } }默认方法同样可以被所有的实现类覆盖重写。接口中的静态方法从Java 8中开始，允许在接口中定义静态方法，静态方法可以使用实现类的对象进行调用，也可以使用接口名直接调用接口中的私有方法从Java 9开始运行在接口中定义私有方法，私有方法可以解决在默认方法中存在大量重复代码的情况。虽然Java为接口中新增了这么多属性和扩展，但是我认为不到万不得已，不要随便乱用这些东西，毕竟接口中应该定义一系列需要实现的标准，而不是自己去实现这些标准。最后总结一下使用接口的一些注意事项:接口没有静态代码块或者构造方法一个类的父类只能是一个，但是类可以实现多个接口如果类实现的多个接口中有重名的默认方法，那么实现类必须重写这个实现方法，不然会出现冲突。如果接口的实现类中没有实现所有的抽象方法，那么这个类必须是抽象类父类与接口中有重名的方法时，优先使用父类的方法，在Java中继承关系优于接口实现关系接口与接口之间是多继承的，如果多个父接口中存在同名的默认方法，子接口中需要重写默认方法，不然会出现冲突final关键字之前提到过final关键字，用来表示常量，也就是无法在程序中改变的量。除了这种用法外，它还有其他的用法修饰类，表示类不能有子类。可以将继承关系理解为改变了这个类，既然final表示常量，不能修改，那么类自然也不能修改修饰方法：被final修饰的方法不能被重写修饰成员变量：表示成员变量是常量，不能被修改修饰局部变量：表示局部变量是常量，在对应作用域内不可被修改

Java 继承 之前说过了Java中面向对象的第一个特征——封装，这篇来讲它的第二个特征——继承。一般在程序设计中，继承是为了减少重复代码。继承的基本介绍public class Child extends Parent{ //TODO } 使用继承后，子类中就包含了父类所有内容的一份拷贝。子类与父类重名成员的访问。重名属性当子类与父类中有重名的数据成员时，如果使用子类对象的引用进行调用，那么优先调用子类的成员，如果子类成员中没有找到那么会向上查找找到父类成员。例如public class Parent{ public int num = 10; } public class Child extends Parent{ public int num = 20; public static void main(String[] args){ Parent obj = new Child(); System.out.println(obj.num); //输出10 Child c = new Child(); System.out.println(c.num); //输出20 } }二者同样是创建的Child对象，那么为何一个是10，而一个是20 呢？ 在C/C++中经常提到一个概念就是，指针本身存储的是一个地址值，指针本身是没有任何数据类型的，而指针指向的地址有，我们在程序中定义的指针类型决定了代码在访问指针所指向的内存时是如何翻译这段内存的。Java中虽然说没有开放操作内存的能力，但是引用本身也是一个指针。如果将父类类型的引用来保存子类对象的地址，那么从引用类型来看，它只能看到父类的相关内容，所以这里它将对象所在内存当做父类的类型，所以第一个打印语句访问到的是父类的 num 成员。而第二个它能看到子类的整个内存，所以说它优先使用子类的 num 成员。上面是第一种情况，即在外部直接调用，如果通过方法来访问呢public class Parent{ private int num = 10; public int getNum(){ return this.num; } } public class Child extends Parent{ public int num = 20; public int getNum(){ return this.num; } public static void main(String[] args){ Parent obj = new Child(); System.out.println(obj.getNum()); //输出20 Child c = new Child(); System.out.println(c.getNum()); //输出20 } }第一条输出语句实际上使用了Java中的多态特性，这个时候会调用子类的方法，而第二条直接调用子类方法，而在子类方法中通过this调用自身的 num 成员，所以这里会输出两个20不管哪种情况，在通过对象的引用调用对象成员的时候会根据引用类型来翻译对应的内存，找到需要访问的变量，如果子类中未找到则向上查找父类，如果父类也未找到，则会报错。下面来看看Java中继承的内存图来加深这个的理解public class Parent{ public int num = 10; public int getNum(){ return this.num; } } public class Child extends Parent{ public int num = 20; public int getNum(){ return this.num; } public void show(){ int num = 30; System.out.println(num); //30 System.out.println(this.num); //20 System.out.println(super.num); //10 } public static void main(String[] args){ Child obj = new Child(); obj.Show(); obj.getNum(); //20 } }对象的内存分布大致如下:首先JVM加载程序的时候将类定义放到方法区中，此时方法区中有两个类的定义，其中子类中有一个 [[class_super]] 标志，用于标明它的父类是哪个。然后创建main的栈并执行main函数，在main函数中创建了一个Child的对象，那么JVM会根据方法区中的相关内容在堆中创建子类对象， 子类对象中包含一整份的父类的拷贝。然后调用Show方法，它首先根据方法区中的标识查找，在子类中找到了这个方法创建方法栈并调用。在方法中，定义了一个局部变量 num，当访问 num这个变量时会首先在栈中查找，如果找到则访问，如果没有则在子类中查找，如果子类中也没有，则会访问父类。就这样在栈中找到了num。接着访问 this.num。 这个时候JVM会首先到子类中查找，找不到则会进一步查找父类。发现在子类中找到了。接着访问 super.num，那么JVM会主动去父类中查找。show方法执行完了之后，JVM回收它的堆栈，接着调用getNum() 方法，查找方式与调用show的相同。后面的就不再说了，与之前的类似。重写向上面的例子中这样的。当子类与父类的方法名、参数列表相同时，如果用子类对象进行调用，那么会调用子类方法，这个时候父类的同名方法就被重写了。注意：这里并没有强调返回值也一样，其实这里只需要返回值能正常的发生隐式转换即可。这里也没有规定它的访问权限，这里只要求子类方法的访问权限大于等于父类方法的访问权限，也就是在同一条件下保证二者都能访问。虽然没有这两方面的限制，但是一般情况下父类的方法与子类重写的方法在形式上应该是完全一样的。public class Parent{ public int num = 10; public int getNum(int n){ return this.num; } } public class Child extends Parent{ public int num = 20; public int getNum(float f){ return this.num; } }上面的代码并没有实现重写的功能，但是如果程序员自己理解不到为，认为这是一个重写，并且在代码中按照重写在使用，那么编译虽然不会报错，但是在运行过程中可能会出现问题，这个时候可以使用 @Overwrite 注解，来告诉编译器，这里是一个重写，如果编译器判断这个不是重写，那么编译会报错，这样就将运行时错误提升到了编译时，有注意bug的排除。注解与注释有什么相同与区别呢：我认为二者都是用于对程序做一个说明，但是注释是给人看的，注解是给机器看的。重写与重载有什么区别呢？重写是发生在类的继承关系中的，要求函数名、参数列表相同重载并没有规定使用的场合，要求函数名相同、而参数列表不同既然说到重载，我想起来了java与c++中重载的一个区别void sayHello(long f); void sayHello(int);根据上述函数的定义，java和c++中都形成了一个重载的关系，如果在C中使用代码 sayHello(10) 来调用的时候，因为这里的10既可以理解为long也可以理解为int，所以这里发生了二义性，编译会报错，而java中 10 默认为int，所以这里会调用int参数的函数，而想要调用long型的参数，得写成 sayHello(10L)。这算是二者之间和有趣的一个现象。构造函数与C/C++中的相同，调用构造的时候会优先调用父类构造，像上面的代码中，并没有明显的调用构造，在创建类的时候会隐式的调用构造，并在子类构造中隐式调用父类构造。但是一旦手工定义了构造，那么编译器将不再额外提供构造。public class Parent{ Parent(int n){ System.out.println(n); } } public class Child extends Parent{ Child(){ //这个会编译报错 System.out.println("Child"); } }Child构造函数默认会调用父类的无参构造，但是由于父类提供了构造，此时编译器不再提供默认的无参构造，所以这里找不到父类的无参构造，报错。这个代码可以进行如下的修改public class Child extends Parent{ Child(){ //这个会编译报错 super(19); System.out.println("Child"); } //或者 Child(int n){ //隐式调用super(n) System.out.println("Child"); } }这里使用super关键字显示调用父类的带参构造。或者定义一个带参构造，编译器会默认为你添加上调用父类带参构造的过程。在Java中super关键字的作用主要有以下几点:在子类中访问父类成员在子类中调用父类构造函数，这种用法必须保证super在子类构造中是第一条被执行的语句，而且只能有唯一的一条我们说super代表父类，那么this代表的就是类本身，那么它有什么具体的作用，又有哪些需要注意的点呢？this可以访问本类成员变量在本类的成员方法中访问另一个成员方法在本类构造方法中访问另一个构造注意：第3中用法中，this关键字必须是构造方法执行的第一条语句，而且只能有唯一的一条。这条规则与super关键字的相同，那么在构造中既有this又有super的时候该怎么办呢？答案是无法这么使用，Java中规定this和super关键字在构造函数中只能出现一个。Java中的 继承关系在C++中，最让人头疼的是多继承的菱形继承关系，为了防止二义性，Java禁止多继承，只允许单继承。但是java中运行多继承，并且一个父类运行有多个子类。在Java的多级继承中如果出现同名的情况，访问时该怎么办呢？原则仍然相同，根据new出来的对象和左侧保存对象的引用类型来判断，如果是父类类型，则访问成员变量时只能访问父类，如果是访问方法则需要考虑多态。如果创建的是父类则只能访问父类的成员变量和方法

java 常见类 上次提前说了java中的面向对象，主要是为了使用这些常见类做打算，毕竟Java中一切都是对象，要使用一些系统提供的功能必须得通过类对象调用方法。其实Java相比于C来说强大的另一个原因是Java中提供了大量可用的标准库字符串字符串可以说是任何程序都离不开的东西，就连一个简单的hello world程序都用到了字符串，当时C语言中对字符串的支持并不太好，C语言中的字符串实质上是一个字符数组。为了方便不同的C/C++库都有自己的字符串实现。而Java中内置了对字符串的支持，Java中的字符串是一个叫做String的对象。根据jdk文档的描述，我们需要注意一下几点：Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例String对象是可以共享的String对象是不可变的字符串的内存分布一般把类似于 "abc" 这样直接通过字面值表示的字符串作为字面常量，这种在Java中也是一个字符串，只是它与普通的new出来的字符串在内存的存储上有点不一样，下面请看下面的代码class StringDemo{ public static void main(String[] args){ String a = "abc"; String b = "abc"; String c = new String("abc"); System.out.println(a == b); System.out.println(a == c); System.out.println(b == c); } }针对字符串来说 == 比较的是它们的地址是否相同，这个程序分别输出的是 true、false、false，也就是说a b 是指向的同一个地址空间，而c则不是。它们的内存分布如下:一般程序在加载到内存地址空间后，会被划分为4个部分，全局数据段、代码段、堆、栈。而全局代码段是用来存放全局变量的。在C中如果我们写下这样的代码:char* psz1 = "abc"; char* psz2 = "abc";那么在程序加载到内存中时，在全局数据段中会存在一个连续的内存空间保存的是 'a','b','c','\0' 这4个值，一旦有char型指针指向"abc" 这样的字符串，那么系统会自动将这段内存的地址给赋值到对应的指针变量中，而且这个内存是只读内存，如果尝试往里面写入数据，则会造成程序崩溃。Java中也是类似的，当出现 "abc" 的时候，其实系统早就为它在堆中创建了一个String对象，如果去阅读String的源码就会发现String中负责保存字符串的是一个 byte型的数组，所以在初始化的时候会再创建一个byte型数组，然后由字符串中成员变量保存它的地址，所以在内存图中看到有String也有byte[]。而且这个字符串是保存在堆中的常量字符串池中的，它的生命周期与程序相同（或者说与主线程相同）。每当直接使用 "abc" 这样的字面常量的时候会自动将常量字符串池中相关的字符串对象的指针赋值给对应的对象。这样造成了上述程序中 a == b 为true的情况。而c是通过new关键字在程序运行期间动态创建的。所以JVM会在程序执行到这步的时候额外创建一个对象，并将 "abc" 这个字符串对应的byte[] 中的值拷贝到新的内存中。这样就很容易理解上面的前两条了，至于字符串不可变，可以参考我之前写的关于类型中的说明(字符串的值发生改变时，在内存中其实是开辟了一块新的内存用于保存新的字符串内容，而丢弃了从前的字符串)常见字符串方法这里再简单的列举一下字符串中常见的方法,这些方法都可以在JDK文档都可以查到。String(); //初始化新创建的 String对象，使其表示空字符序列 String(byte[] bytes); //通过使用平台的默认字符集解码指定的字节数组来构造新的 String String(byte[] bytes, int offset, int length); //从bytes[] 数组中的第offset 位置开始，截取length个成员来初始化一个String char charAt(int index); //返回指定位置处的索引 int compareTo(String anotherString); // 按字典顺序比较两个字符串的大小，为0表示两个字符串相同 int compareToIgnoreCase(String str); //比较两个字符串的大小，忽略大小写 String concat(String str) ; //字符串拼接 byte[] getBytes(Charset charset); //将字符串转化为byte型数组，并返回新的byte数组 int indexOf(String str); //返回字串第一次出现的位置 int length() ; //返回字符串的长度 String[] split(String regex); //按正则表达式进行分割，并返回对应的字符串数组注意一下，这里返回数组或者新字符串的，都是在函数内部新建的，与原来的无关。所以这里是没办法拿到字符串底层的数组对象再来修改内存值的。数组java中数组的定义如下:int[] Array1 = new int[10]; //定义了一个拥有10个整型数据的数组 int[] Array2 = new int[]{1, 2, 3, 4, 5, 6, 7,8, 9, 0}; //创建数组并初始化 int[] Array3 = {1,2 ,3,4,5,6,7,8,9,0}; 相比于C中数组的定义来说，Java中的定义更容易让人理解，对应数据类型后面加一对 [] 就是对应的数组类型了。而C中，中括号是写在变量后面的，相比于Java中的定义来说就显的有点怪异了。或者说C中从根本上来说数组并不算是一种特别的数据类型，仅仅只是开辟相同数据类型的一块连续的内存而已。至于[] 在C中应该只是表示寻址而已，毕竟汇编中我们经常看到类似于 esp:[eax] 这样的东西。Java中的数组是一种单独的数据类型，它是一种引用类型，也就是说它的变量名中保存的是它的地址。它的使用十分的简单，与C/C++中数组的使用基本相同，注意事项也是基本相同。但是有一点很重要的不同，Java中的数组允许动态指定长度，也就是通过变量来指定长度，而C中必须静态的指定长度，也就是在程序运行之前就需要知道它的长度。这是因为Java中数组是引用类型，是new在堆上的，而C中数组是分配在全局变量区或者栈上的，在程序运行之初就需要为数组分配内存。//这样的代码是可以编译通过的 int length = 10; int array[] = new int[length];数组作为函数参数import java.util.Arrays; class Demo{ public static void main(String[] args){ int length = 10; int array[] = new int[length]; System.out.println(Arrays.toString(array)); test(array); System.out.println(Arrays.toString(array)); } public static void test(int[] array){ for(int i = 0; i < array.length; i++) { array[i] = i; } } }运行上述的代码，发现函数中修改array的值在函数结束后也可以生效，这是因为数组是一个引用类型，在C中我们说要想改变实参的值，需要传入对应的引用或者指针。在函数中通过引用访问，实际上在访问对应的内存，所以这里其实是在修改对应内存的值。当然可以修改实参的值了。ArrayList类之前在数组中，我们说数组一旦定义，是不能改变大小的，那么如果我后续需要使用可变大小的数组呢？Java中提供了ArrayList这样的容器。由于它是一个通用的容器，而java又是一个强类型的语言，所以在定义的时候需要事先指定我们需要使用容器存储何种类型的数据。一般ArrayList的定义如下:ArrayList<String> array = new ArrayList(); 表示容器内部存储的是字符串。需要注意的是容器中只能存储引用类型，不能存储像int、double、char这样的基本类型，如果要存储这样的数据，需要存储它们对应的封装类。比如int 类型对应的封装类为 Integer。它的常用方法如下:ArrayList(); //构造方法 boolean add(E e);//添加元素 void clear(); //清空 E get(int index); //获取指定位置的元素 int indexOf(Object o); //查询元素第一次出现的位置 E remove(int index); //删除指定位置的元素 E remove(Object o); //从列表中删除指定元素的第一个出现（如果存在） int size(); //获取容器中元素个数 void sort(Comparator<? super E> c); //使用提供的 Comparator对此列表进行排序键盘输入Java中的键盘输入主要通过Scanner类来实现，Scanner需要提供一个输入流，从输入流中获取输入。一般常用的输入流是 System.in 表示从键盘输入,例如：Scanner sc = new Scanner(System.in);Scanner类中常用方法是一系列的next方法，next方法主要功能是根据指定 的分割符，从输入流中取出下一个输入并做相应的转化，比如nextInt()会转化为int，nextBoolean() 会转化为boolean类型等等，next()方法会直接转化为字符串。默认情况下next函数会通过空格进行转化。import java.util.Scanner; import java.util.ArrayList; class Demo{ public static void main(String[] args){ ArrayList<String> array = new ArrayList<String>(); Scanner sc = new Scanner(System.in); String str = sc.next(); array.add(str); while(sc.hasNext()){ array.add(sc.next()); } for(int i = 0; i < array.size(); i++) { System.out.println(array.get(i)); } } }这段代码，会将输入的数据依次存储到ArrayList容器中。因为程序事先不知道用户会输入多少数据，所以这里采用可以可变长度的容器来存储//输入(> 表示cmd的提示符) >hello world python java c++ c lisp // 输入ctrl + c来退出sc.next的输入 > ctrl+c //输出 >hello world python java c++ c lisp上述代码首先执行到sc.next位置，并且中断下来，我们输入上述的一些字符串，然后回车，然后程序继续执行，在循环中根据空格，依次从里面取出每一个值，并放到容器中。当没有值时，程序会再次中断在sc.next()的位置，这个时候输入 ctrl + c ，此时程序再次执行到 sc.hasNext() 这个地方会返回false，这个时候循环退出，并依次打印这些内容。这个程序证明了上面说的，next方法会根据指定的分割符，依次从输入流中取出下一个输入。当然如果想要一次读取一行，可以使用 nextLine方法。更多内容请查阅JDK文档。

Java 面向对象 现在一般的语言都支持面向对象，而java更是将其做到很过分的地步，java是强制使用面向对象的写法，简单的写一个Hello Word都必须使用面向对象，这也是当初我很反感它的一点，当然现在也是很不喜欢它这一点。但是不得不说它设计的很优秀也很流行。面向对象面向对象一般是将一些独立有相似功能的模块封装起来组成一个类，然后调用者不必关注实现细节而只需要关注调用某个类方法即可。面向对象简化了程序设计。与之相对应的是面向过程，而C就是典型的面向过程的程序设计语言。面向对象一般有3种特性：封装、继承、多态。这次主要讲述的是java中的封装型。在java中类的定义与C++中类的定义类似，只是在java中每定义一个方法或者成员变量都需要在前面添加一个访问的权限修饰符，比如下面的定义class Student { private String name; private int age; public Student(){ } public Student(String name, int age){ this.name = name; this.age = age; } public int getAge(){ return this.age; } public String getName(){ return this.name; } public void setAge(int age){ this.age = age; } public void setName(String name){ this.name = name; } }而C++中只需要将具有相同访问属性的放到一块，用一次修饰符即可。比如上面java代码对应的C++代码如下:class Student { private: string name; int age; public: Student(){ } Student(string name, int age){ this->name = name; this->age = age; } int getAge(){ return this->age; } String getName(){ return this->name; } void setAge(int age){ this->age = age; } void setName(String name){ this->name = name; } }访问权限在C++中类中的成员如果不给访问权限，默认是private, 而java中默认的访问权限是friendly，但是这个friendly在java中并不是关键字，而且java中的public、private、protected 都必须明确指定，在java中这些关键字对应的访问权限如下:访问权限当前类同一个package子孙类其他packagepublicyesyesyesyesprotectedyesyesyesnofirendlyyesyesnonoprivateyesnonono从上一个表中可以看到public 对于类成员的访问完全没有限制、而protected仅仅保护类成员不被其他包访问，默认的friendly只允许同一个包或者同一个类的成员访问，最后的private仅允许同一个类的成员访问，它们的访问权限是递增的，也就是public > protected > friendly > private封装性面向对象的封装性就体现在仅仅允许通过类方法访问类成员。这有助于保护类成员不被其他代码随意的篡改，而且如果类成员在进行修改时如果会涉及到其他变化，我们只需要在get/set方法中控制即可，不需要外部使用人员了解这个细节。假设现在有一个教务系统，里面需要存储学生的信息，那么如果不采用封装的方式而直接在类代码外进行访问的话，而且成员被访问的位置较多，一旦发现数据库中存储的数据发生错误，那么将无法确定是在哪给定了错误的值，而且要对输入值进行判断的时候，每个被访问的位置都要添加这些判断的代码，修改量较大，而且无法保证每个位置都正常修改了。如果后续业务逻辑修改，那么这些工作又得重新做一遍。如果我们将成员变量使用set和get方法进行封装，查看数据错误的问题只需要关注get/set方法，而且业务逻辑变更时只需要修改get/set方法。这点体现了封装性对数据的保护作用。在假设这里我们采用多线程的方式来访问数据，那么为了保护数据，就需要添加相应的同步代码，如果直接访问，那么每当访问一次数据，就需要添加保护代码。这样就为使用人员添加了不必要的麻烦，如果我们将这些进行封装，然后告诉使用人员，这个类是线程安全的，那么使用人员直接调用而不用管其中的细节，后续如果我们换一种同步的方式，也不影响其他人的使用。this关键字C++中this关键字就是一个指针，通过eax寄存器传入到类的成员函数中，在成员函数中，通过this + 偏移地址来定位类中所有成员。而java中this除了能像c++中那样用于表示访问类成员外，还有另外两个作用使用this表示调用类其他的构造函数,比如下面的代码:class Student { private String name; private int age; public Student(){ } public Student(String name){ this(); //调用无参构造 this.name = name; } public Student(String name, int age){ this(name); // 调用有一个参数的构造方法 this.age = age; } public int getAge(){ return this.age; } public String getName(){ return this.name; } public void setAge(int age){ this.age = age; } public void setName(String name){ this.name = name; } }用来表示类的对象，其实这个作用与C++中this指针的作用相同，而且二者本质也一样，只是Java中不能直接访问内存地址，所以这里与C++有些许不同。class Student { private String name; private int age; public Student(){ } public Student(String name){ this(); //调用无参构造 this.name = name; } public Student(String name, int age){ this(name); // 调用有一个参数的构造方法 this.age = age; } public int getAge(){ return this.age; } public String getName(){ return this.name; } public void setAge(int age){ this.age = age; } public void setName(String name){ this.name = name; } public boolean compare(Student stu){ return this == stu; //这里简单实用二者的地址进行比较 } }构造函数与析构函数java中的构造函数与C++中的相同。是在new对象的时候调用的函数。注意这里只是说它在new的时候调用的函数，并不是在使用类的时候第一次调用的函数。Java 中的构造方法必须与该类具有相同的名字，并且没有方法的返回类型。每个类至少有一个构造方法。如果不写一个构造方法，Java 编程语言将提供一个默认的，该构造方法没有参数，而且方法体为空。如果一个类中已经定义了构造方法则系统不再提供默认的构造方法。java中不能直接访问内存，虽然它的类都是new出来的，但是资源的回收由垃圾回收机制来完成，那么它有析构函数吗？答案是肯定的，java中也是有析构函数的。在C++中进行栈资源回收或者手工调用delete的时候才会进行析构函数的调用。而在java中，当垃圾回收器将要释放无用对象的内存时，先调用该对象的finalize（）方法。这个finalize方法就是类的析构函数，这个方法是由Object这个基类提供的一个方法，Object子类可以选择重写它或者就用默认的。这个方法严格上应该是一个接口函数，与C++的析构并不相同。Java 虚拟机的垃圾回收操作对程序完全是透明的，因此程序无法预料某个无用对象的finalize（）方法何时被调用。类的静态代码块上面说构造函数并不是使用类时第一个调用的函数，第一个调用的函数应该是静态代码块（这个代码块应该不能被称之为函数）。静态代码块是第一次使用类的时候被调用，而且仅仅只调用这一次。它的定义如下:class Student{ staic { System.out.println("调用静态代码块"); } }

Java 函数 之前的几篇文章中，总结了java中的基本语句和基本数据类型等等一系列的最基本的东西，下面就来说说java中的函数部分函数基础在C/C++中有普通的全局函数、类成员函数和类的静态函数，而java中所有内容都必须定义在类中。所以Java中是没有全局函数的，Java里面只有普通的类成员函数（也叫做成员方法）和静态函数（也叫做静态方法）。这两种东西在理解上与C/C++基本一样，定义的格式分别为:public static void test(arglist){ } public void test(arglist){ }基本格式为：修饰符 [static] 返回值 函数名称 形参列表修饰符主要是用来修饰方法的访问限制，比如public 、private等等；如果是静态方法需要加上static 如果是成员方法则不需要；后面是返回值，Java函数可以返回任意类型的值；函数名用来确定一个函数，最后形参列表是传递给函数的参数列表。函数中的内存分布Java中函数的使用方式与C/C++中基本相同，这里就不再额外花费篇幅说明它的使用，我想将重点放在函数调用时内存的分配和使用上，更深一层了解java中函数的运行机制。我们说在X86架构的机器上，每个进程拥有4GB的虚拟地址空间。Java程序也是一个进程，所以它也拥有4GB的虚拟地址空间。每当启动一个Java程序的时候，由Java虚拟机读取.class 文件，然后解释执行其中的二进制字节码。启动java程序时，在进程列表中看到的是一个个的Java虚拟机程序。java虚拟机在加载.class 文件时将它的4GB的虚拟地址空间划分为5个部分，分别是栈、堆、方法区、本地方法栈、寄存器区。其中重点需要关注前3个部分。栈：与C/C++中栈的作用相同，就是用来保存函数中的局部变量和实参值的。堆：与C/C++中堆的作用相同，用来存储Java中new出来的对象方法区：用来保存方法代码和方法名与地址的这么一张表，类似于C/C++中的函数表基本数据类型作为函数的参数class Demo{ public static void main(String[] args){ int n = 10; test(10); System.out.println(n); } public static void test(int i){ System.out.println(i); i++; } }上述代码在函数中改变了形参值，那么在调用之后n的值会不会发生变化呢？答案是：不会变化，在C/C++中很好理解，形参i只是实参n的一个拷贝，i改变不会改变原来的n。这里我们从内存的角度来回答这个问题如上图所示，方法区中存储了两个方法的相关信息，main和test，在调用main的时候，首先从方法区中查找main函数的相关信息，然后在栈中进行参数入栈等操作。然后初始化一个局部变量n，接着调用test函数，调用test函数时首先根据方法区中的函数表找到方法对应的代码位置，然后进行栈寄存器的偏移为函数test分配一个栈空间，接着进行参数入栈，这个时候会将n的值——10拷贝到i所在内存中。这个时候在test中修改了i的值，改变的是形参中拷贝的值，与n无关。所以这里n的值不变引用类型作为函数参数class Demo{ public static void main(String[] args){ String s = "Hello"; test(s); System.out.println(s); //"Hello" } public static void test(String s){ System.out.println(s); //"Hello" s = "World"; } }在C/C++中，经常有这么一句话：“按值传递不能改变实参的值，按引用传递可以改变实参的值”，我们知道String 是一个引用，那么这里传递的是String的引用，我们在函数内部改变了s的值，在外部s的值是不是也改变了呢？我们首先估计会打印一个 "Hello"、一个"World"; 实际运行结果却是打印了两个 "Hello",那么是不是有问题呢？Java中到底存不存在按引用传递呢？为了回答这个问题，我们还是来一张内存图：从上面的内存图来看，在函数中修改的仍然是形参的值，而对实参的值完全没有影响。如果想做到在函数中修改实参的值，请记住一点：拿到实参的地址，通过地址直接修改内存。下面再来看一个例子:class Demo{ public static void main(String[] args){ int[] array = new int[]{1, 2, 3, 4, 5}; test(array); for(int i = 0; i < array.length; i++){ System.out.print(array[i]); } System.out.println(); //98345 } public static void test(int[] array){ for(int i = 0; i < array.length; i++){ System.out.print(array[i]); } System.out.println(); //12345 array[0] = 9; array[1] = 8; } }运行这个实例，可以看到这里它确实改变了，那么这里它发生了什么？跟上面一个字符串的例子相比有什么不同呢？还是来看看内存图这段代码执行的过程中经历了3个主要步骤:new一个数组对象，并且将数组对象的地址赋值给array 实参调用test函数时将array实参中保存的地址复制一份压入函数的参数列表中在test函数中，通过这个地址值来修改对应内存中的内容这段代码与上面两段本质上的区别在于，这段代码通过引用类型中保存的地址值找到并修改了对应内存中内容，而上面的两段代码仅仅是在修改引用类型这个变量本身的值。说到传递引用类型，那么我就想到在C/C++中一个经典的漏洞——缓冲区溢出漏洞，那么java程序中是否也存在这个问题呢？这里我准备了这样一段代码:class Demo{ public static void main(String[] args){ byte[] buf = new byte[7]; test(buf); } public static void test(byte[] buf){ for(int i = 0; i < 10; i++){ buf[i] = (byte)i; } } }如果是在C/C++中，这段代码可以正常执行只是最后可能会报错或者崩溃，但是赋值是成功的，这也就留给了黑客可利用的空间。在Java中执行它会发现，它会报一个越界访问的异常，也就说这里赋值是失败的，不能直接往内存里面写，也就不存在这个漏洞了。返回引用类型Java方法返回基本类型的情况很简单，也就是将函数返回值放到某块内存中，然后进行一个复制操作。这里重点了解一下它在返回引用类型时与C/C++不同的点在C/C++中返回一个类对象的时候，会调用拷贝构造将需要返回的类对象拷贝到对应保存类对象的位置，然后针对函数中的类对象调用它的析构函数进行资源回收，那么Java中返回类对象会进行哪些操作？C/C++中返回一个类对象的指针时，外部需要自己调用delete或者其他操作进行析构。java中的类对象都是引用类型，在函数外部为何不需要额外调用析构呢？带着这些问题，来看下面这段代码：class Demo{ public static void main(String[] args){ String s = test(); System.out.println(s); } public static String test(){ // return new String("hello world"); return "Hello World"; } }这段代码 不管是用new也好还是直接返回也好，效果其实是一样的，下面是对应的内存分布图这段代码首先在函数test中new一个对象，此时对应在堆内存中开辟一块空间来保存"hello world" 值，然后保存内存地址在寄存器或者其他某个位置，接着将这个地址值拷贝到main函数中的s中，最后回收test函数的栈空间。这里实质上是返回了一个堆中的地址值，这里就回答了第一个问题：在返回类对象的时候其实返回的值对象所在的堆内存的地址。接着来回答第二个问题：java中资源回收依赖与一个引用计数。每当对地址值进行一次拷贝时计数器加一，当回收拷贝值所在内存时计数器减一。这里在返回时，先将地址值保存到某个位置（比如C/C++中是将返回值保存在eax寄存器中）。此时计数器 + 1；然后将这个值拷贝到 main 函数的s变量中，此时计数器的值再 + 1，变为2，接着回收test函数栈空间，计数器 - 1，变为1，在main函数指向完成之后，main的栈空间也被回收，此时计数器 - 1，变为0，此时new出来的对象由Java的垃圾回收器进行回收。

Java 基本语句、控制结构 上一篇中简单谈了一下自己对Java的一些看法并起了一个头，现在继续总结java的相关语法。java语法总体上与C/C++一样，所以对于一个C/C++程序员来说，天生就能看懂Java代码。在学习java的时候，上手非常快。我感觉自己就是这样，看代码，了解其中一些重点或者易错点的时候发现，与C/C++里面基本类似，甚至很多东西不用刻意去记，好像自己本身就知道坑在哪。所以这里我想简单列举一下语法点，然后尝试用C/C++的视角来解读这些特性。引用类型引用中的指针与内存上一次，我总结一下java中的数据类型，在里面提到，Java中有两大数据类型，分为基本数据类型和引用数据类型。并且说明了简单数据类型，这次就从引用数据类型说起；引用数据类型一般有：数组、字符串、类对象、接口、lambda表达式；这次主要通过数组和字符串来说明它引用数据类型在C/C++中对应指针或者引用。其实关注过我之前C/C++反汇编系列文章的朋友知道，在C/C++中引用实质上就是一个指针。所以这里我也将java中引用类型理解为指针。所以从本质上讲，引用类型都是分配在堆上的动态内存。然后使用一个指针指向这块内存。这是理解引用类型很重要的一点。数组的定义如下char[] a = new char[10]; char[] b = new char[] {'a', 'b', 'c'}; char[] c = {'a', 'b', 'c'};其实这种形式更符合 变量类型 变量名 = 变量值 这种语法结构， char[] 就像是一种数据类型一样，char表示数组中元素类型， []表示这是一个数组类型字符串的简单定义如下:String s = "Hello world";上面说到引用类型都是分配在堆上的。所以字符串和数组实质上都是new 出来的。即使有的写法上并没有new 这个关键字，但是虚拟机还是帮助我们进行了new 操作。有new就一定有delete了。那么哪里会delete呢？这些操作一般都由java的垃圾回收器来处理。我们只管分配。这就帮助程序员从资源回收的工作中解放出来了。这也是java相比于C/C++来说比较优秀的地方。有人可能会说C++中有智能指针，也有垃圾回收机制。确实是这样。但是我觉得还是有点不一样。java是天生就支持垃圾回收，就好像从娘胎生出来就有这个本能，而C/C++是由后天学会的，或者说要刻意的去进行操作。二者还是不一样的。下面有这样一段代码:char[] a = new char[10]; System.out.println(a);我们打印这个a变量，发现它出现的是一个类似16进制数的一个东西。这个东西其实是一个地址的hash值，为什么不用原始值呢？我估计是因为有大神能够根据变量的内存地址进行逆向破解，所以这里为了安全对地址值进行了一个加密。或者为了彻底贯彻Java不操作内存的信念。（我这个推断不知道是不是真的，如果有误，请评论区大牛指正。）这也就证明了我之前说的，引用类型本质上是一个指针。char[] a = new char[]{'a', 'b', 'c'}; char[] b = new char[]{'a', 'b', 'c'}; System.out.println(a); System.out.println(b);上面这段代码，我想学过C/C++的人应该一眼就能看出，这里打印出来的a和b应该是不同的值，这里创建了两块内存。只是内存中放的东西是一样的。char[] a = new char[]{'a', 'b', 'c'}; char[] b = a; b[0] = '0'; b[1] = '1'; b[2] = '2'; System.out.println(a); System.out.println(b);这里从C/C++的角度来看，也很容易理解：定义了两个引用类型的变量，a、b都指向同一块内存，不管通过a还是b来寻址并写内存，下次通过a、b访问对应内存的时候肯定会发现值与最先定义的不同。String s = "hello"; System.out.println(s.hashCode()); s += "world"; System.out.println(s.hashCode());由于Java不具备直接访问内存的能力，不能直接打印出它的内存地址，所以这里用hashCode 得到地址的hash值。通过打印结果说明这个时候s指向的地址已经变了。也就是说虽然可以实现字符串的拼接，但是虚拟机在计算得出拼接的结果后又分配了一块内存用来保存新的值。但是任然用s这个变量来存储地址值，用赵本山的话来说就是“大爷还是那个大爷，大妈已经不是原来的那个大妈了”。也就是说Java分配内存的时候应该是按需分配，需要多少分配多少。不够就回收之前的，再重新按需分配。这就导致了java中字符串和数组的长度是不能改变的。String s = "hello"; System.out.println(s.hashCode()); (s.toCharArray())[0] = 'H'; System.out.println(s.hashCode()); System.out.println(s); // 这里字符串的值不变上述这段代码，通过toCharArray将字符串转化为char类型的数组，然后修改数组中的某一个元素的值，我原来以为这样做相当于在String所在内存中修改，最终打印s时会出现 "Hello" ，但是从结果上来看并没有出现这样的情况，s指向的地址确实没变，但是s也是没变的，那只能解释为toCharArray 又开辟了一块内存，将String中的值一一复制到数组中。在学习中我尝试过各种数据类型强转String s = "Hello World"; char[] a = (char[]) s; int p = (int)s;像这样的代码我发现并不能通过编译。在C/C++中，可以进行任意类型到整型或者指针类型的转化，常见的转化方式就是将变量所在地址进行赋值或者将变量对应的前四个字节进行转化作为int或者指针类型。但是在java中这点好像行不通。Java中强转好像只能在基本数据类型中实现，而在引用类型中通常由函数完成，并且完成时并不是简单的赋值，还涉及到新内存空间的分配问题。越界访问由于C/C++中提供了访问内存的能力，而且由于现代计算机的结构问题，C/C++中存在越界访问的问题，越界访问可以带来程序编写的灵活性，但是也带来的一些安全隐患。对于灵活性，相信学习过Windows或者Linux编程的朋友应该深有体会，系统许多数据结构的定义经常有这类:struct s { char c; } s *p = (s*)new char[100]; 这样就简单的创建了一个字符串的结构。这里C变量只是提供了一个地址值，后续可以根据c的地址来访问它后续的内存。安全问题就是大名鼎鼎的缓冲区溢出漏洞，我在相关博客中也详细谈到了缓冲区溢出漏洞的危害以及基本的利用方式。这里就不在赘述。那么Java中针对这种问题是如何处理的呢? Java中由于不具有内存访问的能力，所以这里它简单记录当前对象的长度，只要访问超过这个长度，立马就会报异常，报一个越界访问的异常。（这里我暂时没有想到对应的java演示代码，所以简单说一下吧）空指针访问还记得C/C++指针中常见的一个NULL吧，既然Java中引用类型相当于一个指针，那么它肯定也存在空指针问题。在Java中空指针定义为null。如果直接访问null引用，一般会报空指针访问异常。char[] c = null; c[0] = 'A'; //异常语句关于引用类型我暂时了解了这么多东西。下面简单列举一下java中的运算符和相关语句结构运算符java中的运算符主要有下列几个:算数运算符: + 、-、 *、 /、 %、 ++、 --、赋值运算符: = 、+=、 -=、%=、/=、*=比较运算符: ==、 >、 <、 >=、 <=、 !=逻辑运算符: &&、 ||、 !、三目运算符位运算符: >>、 <<、 >>>(无符号右移)、 <<<、&、|、~这些运算符用法、要点、执行顺序与C/C++中完全相同。所以这里简单列举。不做任何说明语句结构java中的顺序结构与其他语言中一样，主要有3种顺序结构判断结构: if、if...else、 if...else if...else if...else循环结构：while、for、do while用于与其他语言一样，这里需要注意的是，Java中需要判断的地方只能使用bool值作为判断条件，比如 5 == 3 、 a == 5这样的。在C/C++中有一条编程规范，像判断语句中将常量写在前面就像这样if(5 == a){ //.... }这样主要是为了防止将 == 误写成 = ，因为在C/C++中 只要表达式的值不为0 就是真，像 if(a = 5) 这样的条件是恒成立的。而Java中规定判断条件必须是真或者假，并且规定boolean类型不能转化为其他类型，其他类型也不能转化为boolean，所以 if(a = 5) 这样的语句在Java中编译是不会通过的。

java基础语法 最近抽时间在学习Java，目前有了一点心得，在此记录下来。由于我自己之前学过C/C++，而Java的语法与C/C++基本类似，所以这一系列文章我并不想从基础一点点的写，我想根据我已有的C/C++经验，补充一些需要注意的点，或者java中独特的内容，或者将C/C++进行对比来总结一下学习的内容。为什么要学习java最开始接触到Java还是在学校中开设的一门java编程语言的课，那个时候感觉java很麻烦，写个helloworld要那么多代码。后来学到web编程，我自己搭建的环境总是报错，而且还是jar包的错误。从这个时候起，我对java就没什么好感。后来很多培训机构来学校招生，做讲演，难道大学学了4年，最后还是去了培训机构，而那些培训机构号称4个月完全掌握java，这时我感觉如果我去学了java，那么大学4年出来跟培训班4个月出来有什么差别，既然上了大学，学了计算机，要跟培训机构出来的人不一样，既然是学计算机的，当然得学计算机里面最难的语言，所以我大学从3年级开始学了大半年汇编，又从汇编转到C和C++。但是万事逃不过真香定律，在工作之后，慢慢接触了Java，也了解了java，其实Java并不像我想想的那么简单。但是我心里一直抗拒学它。但是最近工作中确实要用到它，之前在一些博文中提到过，现在我开始带领几个人的小队，里面有java的，有做C的，有Python的，我想作为一个leader，虽然不用干他们的活，但是至少得懂。最主要的还是Java那边提个需求实在太难，java程序员总会跟我说很难，要改代码，动不动就说这个需求得改架构。最后做出来的跟我预计的差别太大。为了有理有据的回怼，也为了更好的带队，我想Java还是得会。说到这里我有感而发：领导给你活，并不是要听你抱怨有多难，要很多东西。既然能告诉你要做这个，那么可行性方面肯定提前做过研究，不要说什么很难，做不了。既然给你了，领导要的是你提出一个解决方案，然后告诉我要多长时间。中间出了问题及时反馈就OK。一直抱怨难，动不动就改架构什么的，只会让领导对你的个人能力产生怀疑，甚至会萌发出换人的想法。所以领导拍下来的活，干就对了。上述是一个原因，还有一个原因；我在关注安全漏洞的时候经常会报出来什么Struts2 漏洞、WebLogic 漏洞，这些都是java的开发框架，很多时候大牛们的博客或者公众号上已经写了漏洞原理，甚至有的还有它验证以及构造POC的思路，但是我就是看不懂，不出POC，我完全不知道如何去检测。为了以后能更好的理解这些java漏洞，我想还是需要好好学一下Java从hello world 开始任何语言都是从hello world开始的，java也不例外，这里我给出hello world的代码public class HelloWorld{ public static void main(String[] args){ System.out.println("hello world"); } }将这段代码保存到HelloWord.java文件中，这里文件的名称必须是HelloWorld.java，文件名与主类的名称相同。然后调用javac进行编译javac HelloWorld.java这个时候会生成.class 文件，这里使用java执行代码java HelloWorld注意执行的时候java指令后面跟的是类名而不是具体的.class文件名。这里我想应该是在执行的时候，java命令根据类名去找对应的.class 文件，将文件中的二进制字节码放到虚拟机中执行。然后由虚拟机去类中查找main函数，从main函数中执行。因此这里文件名必须与类名相同，而且必须要有main函数。再来说说这个main函数前面的修饰词，public 应该表示这个是一个公共方法，也就是外部可以访问，static 表示这个方法是一个静态方法，独立与类存在的。这两个修饰符是必须的要的。java强制使用面向对应，一切都定义在类中，但是程序必须要一个入口函数。根据java的逻辑，这个main函数也得定义到类中。但是如果定义成普通函数的话行不行呢。答案是不行的，由于main函数是一个入口函数，一切都从它开始，如果它是一个类函数，那么势必要定义一个类的对象然后再调用对象的main方法，可是既然main是程序的开始，请问如何在调用main之前定义对象呢，因此这里必须得定义成静态的；这个public能不能不加或者改成private或者其他的呢？当然也不行，既然你要将它作为入口函数，那么必然需要由虚拟机调用这个函数，而且是在类外调用，所以这里一定得定义成public，对外开放。在Java中一切即对象，它强制你采用面向对象，这也是当时我拒绝学java的一个理由，认为它太死板。java的跨平台据说SUN公司当年是卖服务器，服务器上的主要程序是由C/C++开发而来的，而C/C++，每次在换一个平台都需要重新编译。这个时候SUN公司的工程师需要一种跨平台的语言，就那种代码写完，编译完成之后不需要再做任何操作，随便放到一个平台上都能跑的那种。而且当时C++ 指针、多继承满天飞，造成程序编写、理解的困难。基于这几点理由，开发出了Java，Java脱胎于C++，但是砍掉了C++中复杂的指针和多继承的内容，在现在看来应该是一个比较正确的决定。相比于现在C++各种新特性的眼花缭乱，java还是很朴实很简单的东西。java的跨平台取决于它的虚拟机。每个平台都需要一个对应的虚拟机。虚拟机就好像一个翻译，而程序就像一个到不同国家旅行的人，比如说一个中国游客可以去美国、去日本、去英国旅行，他在酒店前台时用中文吩咐前台的工作人员给他一间房，去不同的国家有不同的翻译将开房这条指令翻译为前台能听懂的语言。而我们的游客只需要说中文即可。java的虚拟机的工作原理也是这样的。按照统一的规则，根据具体的平台将规则中定义的指令翻译为对应平台上的机器码。比如在Windows上+1操作是 ADD 1, 在Linux上+1操作是 +1， 而在MAC中对应 1+ ，那么在java代码中这个指令可能会编译为 1++, 这个指令不管在哪个平台都不用变，当它放在windows主机上由Windows版的虚拟机将它翻译为 ADD 1,在Linux上由Linux版的虚拟机翻译为+1，在MAC上由MAC版的虚拟机翻译为 1+。java代码执行需要经过两个步骤，首先编译为虚拟机能识别的字节码，然后有虚拟机解释并执行这个字节码。所以java具有两面性，即需要编译，也需要解释执行，那么它到底是解释性的语言还是编译型的呢？我也不知道。基本语法它的语法与C/C++基本类似，类似到你即使没接触过java，看它的代码基本能看懂每条语句都在干嘛。所以针对我来说，我并不关注每个代码怎么写，我只需要知道每个语法点有哪些需要注意的即可。常量与变量常量在java中一般是指那种用字面值表示出来的量比如说 整型的1,浮点型的1.234, 字符 'A' 字符串 'hello world'，或者是用关键字 const 定义的。java里面的常量分为：整型常量、字符串常量、浮点数常量、字符常量、布尔常量和空常量(null)。从常量类型可以看出这些也是java中主要的数据类型，java中数据类型主要有:整数类型: byte、short、int、long浮点数类型: float、double字符类型: char布尔类型:boolean这些都是基本数据类型，java中还有引用类型，像字符串、对象、数组、接口、lambda表达式都是引用类型。需要注意的是java中long 是8个字节，而C/C++中long一般是4个字节，longlong才是8个。java中的char占两个字节，所以在C/C++中会将需要一个字节一个字节处理的缓冲定义为char型数组，而在java中就不能这么干了，因为它的char占两个字节，java中对于这种情况一般是定义为byte类型的数组。由于java中的char占两个字节，所以java中char是可以表示中文的char c = '中' //这在java中是正确的，但是C/C++中不能这么写有数据类型自然就涉及到数据类型转化的问题。java与C/C++类似都有显示转化和隐式转化。而且写法也类似。需要注意的几点是:整型字面值会被java编译器默认当做int类型来处理，像 byte num = 5、short s = 5 这样的表达式中5 这个字面值都是int，也就是它里面都发生了强制类型转化，如果想让编译器将其当做long需要在5后面加上L，写成 long l = 5L浮点数字面值会被默认当做double 来处理，如果想让其被作为float处理，需要在后面加上F在进行整数运算的时候，运算符号两侧的变量 或者常量会被先转化为int 在进行处理。例如 下面的代码:short s1 = 5, s2 = 10; short result = s1 + s2;这段代码java会报错，由于在运算的时候s1 与 s2 会被转化为int，然后运算得到的结果也是int，在最后进行结果赋值的时候将int赋值为short会发生错误。要让他不报错可以改为 short result = (short)(s1 + s2);隐式类型转化发生在由表示范围小的向表示范围大的类型，一般是 byte-->short-->int-->long-->float-->double。再来看下面一个例子:short n = 5 + 10;这段代码，从理论上讲，它应该会首先把5 和 10 转化为int，在计算，最后把结果的int转化为short赋值，根据上面说的，它应该会报错才对，但是实际试验的结果却是，它通过了。这就很奇怪了。还记得在学习C/C++中提到的编译器的优化吗。在C/C++中如果你写上面的一段代码，在release版本中，你看不到类似mov eax, 5 add eax, 10 mov n, eax这样的机器指令，只看得到mov n, 15这里编译器进行了优化，你代码中采用了字面值常量进行相加，而常量是不会变化的，因此在程序运行之前就已经知道计算的结果，我就没必要在运行的时候浪费CPU给你计算这个加法值，我直接给你一个结果也是一样的。所以这里java编译器采用了同样的策略。它直接将上面的代码翻译为了 short n = 15。但是这也不对啊，15应该会被当做int，而n是一个short，将int这个表示范围大的转化为short这个表示范围小的，应该会报错才对啊。但是编译确实不报错。这又涉及到java编译器的另一个策略了。当我们直接用字面值常量进行赋值操作的时候，如果字面值没有超过左侧变量的表示范围时，编译器会自动进行强制类型转化。最后的最后我想在你已经拥有其他语言的开发经验的时候，学习新语言的过程无外乎是数据类型、基本语句、控制结构、函数、面向对象、以及常用库这些东西，所以我想我自己的java笔记也按照这些框架来组织。这次是数据类型，下次就是基本语句与控制结构了。