java，

java，

继承类:可以直接用一些已经实现了的,定义抽象的.
实现接口:需要全实现因为接口中都是抽象的.

数组长度固定,集合长度可变.使用相应的toArray()和Arrays.asList()方法可以互相转换。
java不支持多继承但支持多实现.

构造方法在实例化时调用一次,普通方法可以调用多次.

执行上构造代码块先于构造函数

重载:再写一个或几个方法(参数个数不同)
重写:在原方法上重新实现

JAVA中类方法是静态方法,python不是(Java中成员变量可以分为：
实例属性 （不用static修饰）
随着实例属性的存在而存在
类属性 （static修饰）
随着类的存在而存在。成员变量是在类范围内定义的变量
局部变量是在一个方法内定义的变量)

|区别|接口|抽象类|
|—|
|构成|构造方法 普通方法 抽象方法 static方法 常量 变量|抽象方法 全局常量|
|关系|单继承但可以实现多个接口|不可以继承抽象类可以继承多个父接口|
|权限|使用各种权限|只能使用public权限|
||子类要实现其所有的抽象方法|子类要实现其所有的抽象方法|

设计模式——单例模式、工厂模式、代理模式、观察者模式、装饰器模式

因为被throws关键字声明的方法,表示此方法不处理异常，而交给方法调用处进行处理。所以调用了使用throws的方法的话,不论操作是否出现异常都需要try catch语句进行异常处理.
|throws|throw|
|-|
|方法声明后面使用throws抛出异常|方法体中使用throw抛出异常|
| |类似于python中的raise,可以抛出自定义异常|
||(python:raise Exception(“抛出一个异常”) );(java:throw new Exception(“抛出一个异常”)|

class mymath{
//使用throws如果出现异常交由调用处处理
public static int div(int x,int y) throws Except
int result = 0;
System.out.println("1");
try{
result = x/y;
//不使用catch只是用try...finally效果一样
}catch (Exception e){
throw e; //抛出异常
//使用finally无论是否有异常都执行
}finally{
System.out.println("2");
}
return result;
}
}

java23种设计模式,
单例设计模式:懒汉式,需要的时候在进行实例化;饿汉式,不管需不需要先进性实例化.饿汉式可能造成资源浪费,懒汉式在多线程调用时由于需要进行判断实例是否已经创建会影响调用速度.
|实现方式|设计模式|
|-|
|懒汉式; 饿汉式; 静态内部类(可实现延迟加载); 枚举式(使用eum方法)|单例设计模式|

java枚举:首先使用 enum 来定义一个枚举类；然后每个枚举值（即声明的枚举）是使用逗号隔开，如果枚举值后面还有操作代码，那么在最后一个枚举值后面加上分号结尾；最后一定要记住，枚举类中声明的每一个值都是一个实例，也就是说有 n 个枚举值，构造函数就被调用 n 次来创建出 n 个枚举实例。这里举一个小例子看看:

enum SeasonType {
    SPRING, SUMMER, AUTUMN, WINTER;
    SeasonType() {
        System.out.println("看看此构造函数被调用了几次");
    }
}
public class Season {
    public static void main(String[] args) {
        System.out.println(SeasonType.SPRING);
    }
}


看看此构造函数被调用了几次
看看此构造函数被调用了几次
看看此构造函数被调用了几次
看看此构造函数被调用了几次
SPRING

工厂设计模式,创建(new)和调用分离:

不使用工厂:

package test;


interface Fruit { 
	public void eat();
}

class Apple implements Fruit{ //定义苹果
	public void eat() {
		System.out.println("**吃苹果");
		} 
}

class Orange implements Fruit{
	public void eat() {
		System.out.println("**吃橘子。"); 
		}
}

public class test{
	public static void main(String args[]){
		Fruit f = new Apple() ;
		f.eat() ;
			}
		}
}
使用工厂:

package test;


interface Fruit { 
	public void eat();
}

class Apple implements Fruit{ //定义苹果
	public void eat() {
		System.out.println("**吃苹果");
		} 
}

class Orange implements Fruit{
	public void eat() {
		System.out.println("**吃橘子。"); 
		}
}

class Factory{
	public static Fruit getInstance(String classname){
		if ("apple".equals(classname)){
			return new Apple();
		}else if ("orange".equals(classname)){
			return new Orange();
		}
		return null ;
	}
}

public class test{
	public static void main(String args[]){
		Fruit f = Factory.getInstance("Orange") ;
		f.eat() ;
			}
		}
}

使用工厂模式好处:假设有代码包A和代码包B，代码包B是代码包A的调用者，A向B暴露接口InterfaceA。
在A的内部结构中，实现了InterfaceA的有ClassA1,ClassA2,ClassA3,……ClassA100。
但是B并不关心这些，因为对于B来说，A的功能只有一个，就是InterfaceA。

这个时候，B想要使用一个InterfaceA的实现，想要new一个出来，但又不想与代码包A中的复杂的构造逻辑耦合，怎么办？

只能向代码包A中传递参数，交给代码包A自己选择到底是那个ClassA1还是A100被new出来。
而这个对构造过程进行选择的逻辑，就是工厂。
如此使代码结构清晰，有效地封装变化。调用者只关心接口就可以了，至于具体的实现，调
用者根本无需关心。

对象序列化:把对象转换为字节序列的过程称为对象的序列化(对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。)

反射:帮助解耦和增强代码可扩展性;
使用工厂设计模式下:

package test;


interface Fruit { 
	public void eat();
}

class Apple implements Fruit{ //定义苹果
	public void eat() {
		System.out.println("**吃苹果");
		} 
}

class Orange implements Fruit{
	public void eat() {
		System.out.println("**吃橘子。"); 
		}
}

class Factory{
	public static Fruit getInstance(String classname){
		if ("apple".equals(classname)){
			return new Apple();
		}else if ("orange".equals(classname)){
			return new Orange();
		}
		return null ;
	}
}

public class test{
	public static void main(String args[]){
		Fruit f = Factory.getInstance("Orange") ;
		f.eat() ;
			}
		}
}

package test;


interface Fruit { 
	public void eat();
}

class Apple implements Fruit{ //定义苹果
	public void eat() {
		System.out.println("**吃苹果");
		} 
}

class Orange implements Fruit{
	public void eat() {
		System.out.println("**吃橘子。"); 
		}
}

class Factory{
	public static Fruit getInstance(String className){
		Fruit fruit = null ;
		try{
			fruit = (Fruit) Class.forName(className).newInstance() ;//使用反射实例化对象而没有使用new关键字
			}catch(Exception e ){
				e.printStackTrace() ;
				}
		return fruit ;
		}
}

public class test{
	public static void main(String args[]){
		Fruit f = Factory.getInstance("test.Orange") ;
		if(f!=null){ //判断是否取得接口实例
			f.eat() ;
			}
		}
}

如果不用反射，那么我们如果再加一个西瓜类，就得在Factory里判断，每添加一个类都要修改一次Factory，但用了反射只用在调用的时候传入完整的类名就可完成。结果：用反射，修改一处代码；不用反射，修改两处代码。

java是强类型语言,变量具有明确类型声明,所以使用泛型可以在同一份代码上操作多种数据类型.
class fanxingClass{}
其中T是型的参数类型. 特点:泛型的参数类型可以使泛型类;泛型类可以同时设置多个类型参数;

抽象类可以有自己的构造方法，但是不能直接通过new进行实例化。但是可以通过子类继承，实例化子类的时候抽象类也会被实例化。因为子类在实例化之前，一定会先实例化它的父类。这样创建了继承抽象类的子类对象，也就把其父类（抽象类）给实例化了。

Thread与Runable:Thread是Runable子类,

package test;
 
public class test extends Thread {
 
	private int tickets = 10;
 
	@Override
	public void run() {
 
		for (int i = 0; i <= 100; i++) {
		   //synchronized(this){加上同步代码块进行线程同步
			if(tickets>0){
				System.out.println(Thread.currentThread().getName()+"--卖出票：" + tickets--);
			}
		}
	}
	
	
	public static void main(String[] args) {
		test myRunnable = new test();
		Thread thread1 = new Thread(myRunnable, "窗口一");
		Thread thread2 = new Thread(myRunnable, "窗口二");
		Thread thread3 = new Thread(myRunnable, "窗口三");
 
		thread1.start();
		thread2.start();
		thread3.start();
	}
 
}

运行结果:
窗口一--卖出票：8
窗口三--卖出票：9
窗口二--卖出票：10
窗口三--卖出票：6
窗口一--卖出票：7
窗口三--卖出票：4
窗口二--卖出票：5
窗口三--卖出票：2
窗口一--卖出票：3
窗口二--卖出票：1

以上代码将extends Thread替换成implements Runnable效果一样.
要避免乱序输出需要进行线程同步可使用synchronized:

maven实现对java依赖管理类似于python的pip,Maven使用pom.xml定义项目内容，并使用预设的目录结构 在Maven中声明一个依赖项可以自动下载并导入classpath Maven使用groupId，artifactId和version唯一定位一个jar包.

异常处理:
1,如果没有写处理异常代码虚拟机会帮助处理把异常信息显示在控制台同时终止代码运行.
2,使用try catch捕获异常,进行处理.
3,使用throws向上抛出异常让调用者处理.
异常分类:
1,编译时异常如IO异常(Exception子类)
2,运行时异常如除零异常ArithmeticException(RuntimeException子类)
代码块:
1,构造代码块,直接写在类中,作为构造方法的共用代码,每次创建对象都会执行,并在构造方法之前执行.
2,局部代码块,写在局部方法中,控制变量作用范围.
3静态代码块,直接写在类中,随着类的加载而加载但只加载一次(区别于构造代码块).(static方法不同于static块，不会自动执行的，只有你在代码中显示的调用)

java和C++都是高级语言,java因为jvm而具有跨平台特性(开发人员不需考虑系统环境可以专注于解决问题),因为jvm虚拟机无法直接执行java高级语言所以将.java格式语言编译成.class字节码文件再通过jvm虚拟机执行.而c++是直接将代码编译成机器语言,所以需要程序人员在编写代码时考虑对应平台问题比如是arm平台还是X86平台.

Java程序最初是仅仅通过解释器解释执行的，即对字节码逐条解释执行，这种方式的执行速度相对会比较慢，尤其当某个方法或代码块运行的特别频繁时，这种方式的执行效率就显得很低。于是后来在虚拟机中引入了JIT编译器（即时编译器），当虚拟机发现某个方法或代码块运行特别频繁时，就会把这些代码认定为“Hot Spot Code”（热点代码），为了提高热点代码的执行效率，在运行时，虚拟机将会把这些代码编译成与本地平台相关的机器码，并进行各层次的优化，完成这项任务的正是JIT编译器。
使用了jit编译器的jvm同时采用了解释执行与编译执行.
解释执行：将编译好的字节码一行一行地翻译为机器码执行。
编译执行：以方法为单位，将字节码一次性翻译为机器码后执行。

todo:反射,反序列化,线程安全