Java内存：
JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)
堆区:
1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身
栈区:
1.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中
2.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
方法区:
1.又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。
2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。
为了更清楚地搞明白发生在运行时数据区里的黑幕，我们来准备2个小道具（2个非常简单的小程序）。
AppMain.java public class AppMain { //运行时, jvm 把appmain的信息都放入方法区 public static void main(String[] args) { //main 方法本身放入方法区。 Sample test1 = new Sample( " 测试1 " ); //test1是引用，所以放到栈区里， Sample是自定义对象应该放到堆里面 Sample test2 = new Sample( " 测试2 " ); test1.printName(); test2.printName(); } } Sample.java public class Sample{ //运行时, jvm 把appmain的信息都放入方法区 private name; //new Sample实例后，name引用放入栈区里，name对象放入堆里 public Sample(String name){ this.name = name; } public void printName(){ //print方法本身放入 方法区里。 System.out.println(name); } }
面向过程：(procedure oriented programming POP)
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；
Java面向对象：(object oriented programming OOP)
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
在类中定义的其实都是成员：
1.成员变量：就是对应事务的属性。2.成员函数：就是对应事物的行为
Java匿名函数：
匿名对象使用方法一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
如果对一个对象进行多个成员的调用，就必须给这个对象起个名字。
匿名对象使用方法二：可以将匿名对象作为实际参数进行传递
java中的匿名类有一个倍儿神奇的用法，见下面代码示例:
package contract;
public interface ISay { void sayHello(); }
上面是一个简单的接口，下面是如何使用：
package jimmy; import contract.ISay; public class Program { public static void main(String[] args) { ISay say = new ISay() { public void sayHello() { System.out.println("Hello java!"); } }; } }
重载和重写的区别。
override重写覆盖
1、方法名、参数、返回值相同。
2、子类方法不能缩小父类方法的访问权限。
3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
4、存在于父类和子类之间。
5、方法被定义为final不能被重写。
overload重载过载
1、参数类型、个数、顺序至少有一个不相同。
2、不能重载只有返回值不同的方法名。
3、存在于父类和子类、同类中。
成员变量和局部变量
根据定义变量位置的不同，可以将变量分为成员变量和局部变量
实参与形参
当传值调用时，改变的是形参的值，并没有改变实参的值，实参的值可以传递给形参，但是，这个传递是单向的，形参不能传递回实参。
当引用调用时，如果参数是对象，无论对对象做了何种操作，都不会改变实参对象的引用，但是如果改变了对象的内容，就会改变实参对象的内容。
举两个例子：
1）方法体内改变形参引用，但不会改变实参引用 ，实参值不变
public class TestFun2 { public static void testStr(String str){ str="hello";//型参指向字符串 “hello” } public static void main(String[] args) { String s="1" ; TestFun2.testStr(s); System.out.println("s="+s); //实参s引用没变，值也不变 } } 执行结果打印：s=1
public class TestFun4 { public static void testStringBuffer(StringBuffer sb){ sb.append("java");//改变了实参的内容 } public static void main(String[] args) { StringBuffer sb= new StringBuffer("my "); new TestFun4().testStringBuffer(sb); System.out.println("sb="+sb.toString());//内容变化了 } } 执行结果，打印：sb=my Java 。
所以比较参数是String和StringBuffer 的两个例子就会理解什么是“改变实参对象内容”了。
Java中普通代码块，构造代码块，静态代码块区别
1 普通代码块
//普通代码块：在方法或语句中出现的{}就称为普通代码块。普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--“先出现先执行” public class CodeBlock01{ public static void main(String[] args){ { int x=3; System.out.println("1,普通代码块内的变量x="+x); } int x=1; System.out.println("主方法内的变量x="+x); { int y=7; System.out.println("2,普通代码块内的变量y="+y); }
} }
运行结果：1.普通代码块内的变量x=3
2.主方法内的变量x=1
3.普通代码块内的变量y=7
2 构造代码块
//构造块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。 public class CodeBlock02{ { System.out.println("第一代码块"); } public CodeBlock02(){ System.out.println("构造方法"); } { System.out.println("第二构造块"); } public static void main(String[] args){ new CodeBlock02(); new CodeBlock02(); new CodeBlock02(); } }
/* 执行结果：
第一代码块，第二构造块，构造方法
第一代码块，第二构造块，构造方法
*/
3 静态代码块
//静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。 //如果类中包含多个静态代码块，那么将按照"先定义的代码先执行，后定义的代码后执行"。 //注意：1 静态代码块不能存在于任何方法体内。2 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。 class Code{ { System.out.println("Code的构造块"); } static{ System.out.println("Code的静态代码块"); } public Code(){ System.out.println("Code的构造方法"); } } public class CodeBlock03{ { System.out.println("CodeBlock03的构造块"); } static{ System.out.println("CodeBlock03的静态代码块"); } public CodeBlock03(){ System.out.println("CodeBlock03的构造方法"); } public static void main(String[] args){ System.out.println("CodeBlock03的主方法"); new Code(); new Code(); new CodeBlock03(); new CodeBlock03(); } } /* CodeBlock03的静态代码块 CodeBlock03的主方法 Code的静态代码块 Code的构造块 Code的构造方法 Code的构造块 Code的构造方法 CodeBlock03的构造块 CodeBlock03的构造方法 CodeBlock03的构造块 CodeBlock03的构造方法 */
封装：
好处：将变化隔离；便于使用；提高重用性；安全性。特点： 1，想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
Java23中设计模式：
总体来说设计模式分为三大类：
创建型模式:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
1):将采用单例设计模式的类的构造方法私有化（采用private修饰）。
2):在其内部产生该类的实例化对象，并将其封装成private static类型。
3):定义一个静态方法返回该类的实例。
/** * 方法一 * 单例模式的实现：饿汉式,线程安全 但效率比较低 */ public class SingletonTest { // 定义一个私有的构造方法 private SingletonTest() {} // 将自身的实例对象设置为一个属性,并加上Static和final修饰符 private static final SingletonTest instance = new SingletonTest(); // 静态方法返回该类的实例 public static SingletonTest getInstancei() { return instance; } } /** *方法二 * 单例模式的实现：饱汉式,非线程安全 * */ public class SingletonTest { // 定义私有构造方法（防止通过 new SingletonTest()去实例化） private SingletonTest() { } // 定义一个SingletonTest类型的变量（不初始化，注意这里没有使用final关键字） private static SingletonTest instance; // 定义一个静态的方法（调用时再初始化SingletonTest，但是多线程访问时，可能造成重复初始化问题） public static SingletonTest getInstance() { if (instance == null) instance = new SingletonTest(); return instance; } } /** * 方法三 * 单例模式最优方案 * 线程安全 并且效率高 * */ public class SingletonTest { // 定义一个私有构造方法 private SingletonTest() {} //定义一个静态私有变量(不初始化，不使用final关键字，使用volatile保证了多线程访问时instance变量的可见性，避免了instance初始化时其他变量属性还没赋值完时，被另外线程调用) private static volatile SingletonTest instance; //定义一个共有的静态方法，返回该类型实例 public static SingletonTest getIstance() { // 对象实例化时与否判断（不使用同步代码块，instance不等于null时，直接返回对象，提高运行效率） if (instance == null) { //同步代码块（对象未初始化时，使用同步代码块，保证多线程访问时对象在第一次创建后，不再重复被创建） synchronized (SingletonTest.class) { //未初始化，则初始instance变量 if (instance == null) { instance = new SingletonTest(); } } } return instance; } }
继承（面向对象特征之一）
好处：
1：提高了代码的复用性。
2：让类与类之间产生了关系，提供了另一个特征多态的前提
如果想要调用父类中的属性值，需要使用一个关键字：super
This：代表是本类类型的对象引用。
Super：代表是子类所属的父类中的内存空间引用。
注意：子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用在定义了，直接继承过来用就可以了。
注意：
子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();
如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。
如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数
问题：
super()和this()是否可以同时出现的构造函数中。
两个语句只能有一个定义在第一行，所以只能出现其中一个。
super()或者this():为什么一定要定义在第一行？
因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。
抽象类:abstract
抽象：
不具体，看不明白。抽象类表象体现。在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。
抽象类的特点：
1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
2：抽象方法只定义方法声明，并不定义方法实现。
3：抽象类不可以被创建对象(实例化)。
4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
抽象类的细节：
1：抽象类中是否有构造函数？
有，用于给子类对象进行初始化。
2：抽象类中是否可以定义非抽象方法？
可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。
3：抽象关键字abstract和哪些不可以共存？
final , private , static
4：抽象类中可不可以不定义抽象方法？
可以。抽象方法目的仅仅为了不让该类创建对象。