chennan132的博客

无限循环的最简单表现形式。 for(;;){} while(true){}1,获取1~10的和，并打印。class ForTest2{ public static void main(String[] args) { /* //1,定义变量用于存储不断变化的和。 int sum = 0; //2，定义变量，记录住不断变化的被加的数。 int x = 1;

/*当多个类中出现相同功能，但是功能主体不同，这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。 抽象：看不懂。 抽象类的特点：1，抽象方法一定在抽象类中。2，抽象方法和抽象类都必须被abstract关键字修饰。3，抽象类不可以用new创建对象。因为调用抽象方法没意义。4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象

/*接口：初期理解，可以认为是一个特殊的抽象类当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。class用于定义类interface 用于定义接口。 接口定义时，格式特点：1，接口中常见定义：常量，抽象方法。2，接口中的成员都有固定修饰符。常量：public static final方法：public abstract 记住：接口中的成员都

/*多态：可以理解为事物存在的多种体现形态。人：男人，女人动物：猫，狗。猫 x = new 猫();动物 x = new 猫();1，多态的体现父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。2，多态的前提必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。3，多态的好处多态的出现大大的提高程序的扩展性。

第二个问题：如何使用子类特有方法。class DuoTaiDemo2 { public static void main(String[] args) { //Animal a = new Cat();//类型提升。 向上转型。 //a.eat(); //如果想要调用猫的特有方法时，如何操作？ //强制将父类的引用。转成子类类型。向下转型。 ///Cat c = (

/*基础班学生： 学习，睡觉。高级班学生： 学习，睡觉。可以将这两类事物进行抽取。*/abstract class Student{ public abstract void study(); public void sleep() { System.out.println("躺着睡"); }}class DoStudent{ public void do

/*在多态中成员函数的特点：在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。在运行时期：参阅对象所属的类中是否有调用的方法。简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。  在多态中，成员变量的特点：无论编译和运行，都参考左边(引用型变量所属的类)。  在多态中，静态成员函数的特点：无论编译和运行，都参考做左边。*/  }} class

/*需求：电脑运行实例，电脑运行基于主板。*/interface PCI{ public void open(); public void close();}class MainBoard{ public void run() { System.out.println("mainboard run "); } public void usePCI(PCI p)/

/*Object:是所有对象的直接后者间接父类，传说中的上帝。该类中定义的肯定是所有对象都具备的功能。 Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。*/class Demo //extends Object{ private int num;

/*内部类的访问规则：1，内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this2，外部类要访问内部类，必须建立内部类对象。 访问格式：1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。格式外部类名.内部类名  变量名 = 外部类

/*异常：就是程序在运行时出现不正常情况。异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。 对于问题的划分：两种：一种是严重的问题，一种非严重的问题。 对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。对与非严重的，ja

class Demo{ int div(int a,int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。 { return a/b; }}class ExceptionDemo1{ public static void main(String[] args) //throws Exception { Demo d

对多异常的处理。 1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。建立在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace(),也不要简单的就书写一

/*因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题。进行自定义的异常封装。 自定义异常。 需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的。那么就需要对这个问题进行自定义的描述。 当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理

/*Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。 如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。 如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过； 之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修

首先介绍一下什么是Map。在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key，其对应的对象叫做value。这就是我们平时说的键值对。HashMap通过hashcode对其内容进行快速查找，而 TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定

关于StringBuilder，一般同学只简单记住了，字符串拼接要用StringBuilder，不要用＋，也不要用StringBuffer，然后性能就是最好的了，真的吗吗吗吗？还有些同学，还听过三句似是而非的经验：1. Java编译优化后＋和StringBuilder的效果一样；2. StringBuilder不是线程安全的，为了“安全”起见最好还是用StringBuffer；3.

/*final : 最终。作为一个修饰符，1，可以修饰类，函数，变量。2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。3，被final修饰的方法不可以被复写。4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。而这

/*子父类出现后，类成员的特点： 类中成员：1，变量。2，函数。3，构造函数。 1,变量如果子类中出现非私有的同名成员变量时，子类会覆盖父类的变量，只会有子类的变量而没有父类的变量子类要访问本类中的变量，用this子类要访问父类中的同名变量，用super。 super的使用和this的使用几乎一致。this代表的是本类对象的引用。su

将学生和工人的共性描述提取出来，单独进行描述，只要让学生和工人与单独描述的这个类有关系，就可以了。继承：1，提高了代码的复用性。2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。 注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系 is a。class C{void demo1(){}} cla

class FunctionDemo { public static void main(String[] args) { /* int x = 4; System.out.println(x*3+5); x = 6; System.out.println(x*3+5); */ //int y = 4*3+5; //int z = 6*3+5; /

Java内存管理分为四个部分1， 栈内存： 局部变量,2，堆内存： 成员变量，  new对象，数组，3，静态区： string字符串常量，static静态变量，4，代码区：程序方法中的二进制代码class ArrayDemo3 { public static void main(String[] args) { int[] arr = {3,6,5,1,8,9,67

（1）选择排序思想：每一次都是一对多，把最左边的值和剩余的所有值比较。（2）冒泡排序思想：每次都是相邻的两个元素进行比较，如果符合条件就交换。import java.util.*;/*对给定数组进行排序。{5,1,6,4,2,8,9}*/class ArrayTest2 { /* 选择排序。内循环结束一次，最值出现头角标位置上。 */ p

（1）选择排序思想：每一次都是一对多，把最左边的值和剩余的所有值比较。（2）冒泡排序思想：每次都是相邻的两个元素进行比较，如果符合条件就交换。

面试：面向对象的思考方法面向对象： 复杂问题简单化           从执行者变成指挥者 举例：结合面试官的现实场景  面向对象：三个特征：封装，继承，多态。以后开发：其实就是找对象使用。没有对象，就创建一个对象。找对象，建立对象，使用对象。维护对象的关系。 类就是：对现实生活中事物的描述。对象：就是这类事物，实实在在存在个体。 现实生活中

class Car{ String color = "红色";//描述颜色 int num = 4; //描述轮胎数 void run() { System.out.println(color+".."+num); }}class CarDemo{ public static void main(String[] args) { //生产汽车。在java中通过ne

/*成员变量和局部变量。作用范围。成员变量作用于整个类中。局部变量变量作用于函数中，或者语句中。在内存中的位置：成员变量：在堆内存中，因为对象的存在，才在内存中存在。局部变量：存在栈内存中。*/ 匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。如果对一个对象进行多个成员调用，必须给这个对象起个名字。匿名对象使用方

/*private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。私有只在本类中有效。 将age私有化以后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在Person类中提供对应访问age的方式。注意：私有仅仅是封装的一种表现形式。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。

/*对象一建立就会调用与之对应的构造函数。构造函数的作用：可以用于给对象进行初始化。构造函数的小细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。 当在类中自定义了构造函数后，默认的构造函数就没有了。构造函数和一般函数在写法上有不同。 在运行上也有不同。构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行

/*this:看上去，是用于区分局部变量和成员变量同名情况。this：就代表本类的对象，到底代表哪一个呢？this代表它所在函数所属对象的引用。简单说：哪个对象在调用this所在的函数，this就代表哪个对象。this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用了了本类对象，都用this表示。*/c

用法：是一个修饰符，用于修饰成员(成员变量，成员函数).当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。  static特点：1，随着类的加载而加载。   也就说：静态会随着类的消失而消失。说明它的生命周期最长。2，优先于的对象存在明确一点：静态是先存在。对象是后存在的。3，被所有对象所共享4，可以直接

/*public static void main(String[] args)主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。主函数的定义：public：代表着该函数访问权限是最大的。static：代表主函数随着类的加载就已经存在了。void：主函数没有具体的返回值。main：不是关键字，但是是一个特殊的单词，可以被jvm识别。（String[]

每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。 虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。发现了问题：1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。 这时就考虑，让程序更严谨，是不需要对象的。可以将Arr

格式：static{         静态代码块中的执行语句。} 特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。 */ 执行顺序：1：静态代码块:2：构造函数3：主函数

设计模式：解决某一类问题最行之有效的方法。java中23种设计模式：单例设计模式：解决一个类在内存只存在一个对象。  想要保证对象唯一。1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。 这三部怎么用代码体现呢

将学生和工人的共性描述提取出来，单独进行描述，   只要让学生和工人与单独描述的这个类有关系，就可以了。 继承：1，提高了代码的复用性。2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。 注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系 is a。class C{ void demo1(){}}

最近在研究hadoop过程当中遇到了一些原来java的一些知识点，感觉有些生疏就和实验室的师兄讨论了一下，遇到了java内存泄漏问题，感觉以前本科阶段对于java内纯泄漏这部分理解很是不清楚，在做工程的过程中，感觉从实践当中理会的更深了。下面就讲一讲我自己的一些看法，仅供参考，如果有什么不对的地方还请大家见谅哈，内容如下：         Java内存管理机制在C++ 语言中，如果需要动态