POJO

普通类

          1.属性：状态、特征
          2.方法：行为(在业务里就用在业务逻辑封装中)
          3.构造方法：（内部特征）
                    (1)默认构造方法[无返回值、方法名和类名一样、无参数]：职责单一，创建对象
                    (2)有参构造：创建对象、初始化成员变量

内部类

          定义：写在一个类里的类(只供外部类使用,其他类不能使用)

pubic class Outer{	//此处Inner为内部类，Outer为外部类	
  
	class Inner{   //外部类访问内部类的方法： Outer.Inner inner=new Outer().new Inner();
				//此时对象inner就可以调用内部类的变量和方法
	}

}

内部类可以访问外部类私有成员（特殊权限）[启动封装]
外部类私有成员对外不开放对内开放

POJO

1.私有属性，封装体现
2.增加get/set对应方法，大多情况下都有set、get
3.附带：增加toString()方法，覆盖Object.toString() （覆盖为@Override）

public class User {

	//一个User的POJO类

	private String name;
	private String age;
	private String height;
	private String id;
	private String address;
	public User(){
		super();
	}
	public User(String name,int age,int height,String id,String address){
		this.name=name;
		this.age=Integer.toString(age)+"岁";
		this.height=Integer.toString(height)+"kg";
		this.id=id;
		this.address=address;	
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
		System.out.println("xmwokdwioedj");
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	public String getHeight() {
		return height;
	}
	public void setHeight(String height) {
		this.height = height;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + ", height=" + height
				+ ", id=" + id + ", address=" + address + "]";
	}
	
	private void eat(String name){
		this.name=name;
		System.out.println(name+"在吃萝卜");
	}
	private void run(){
		System.out.println("user会跑 不是loser");
	}
}

封装（private）

日常代码用public修饰符(公用、不安全)；而封装不直接对外公开，方法内就进行判断；
封装使用private修饰符使只有本类方法可使用，外类调用就无权限。在本类中使用get/set方法设置权限校验代码

继承

          1.extends(实现继承)：子类继承父类
          2.implements(接口继承)：接口方式规定子类

优势	劣势
代码复用	耦合度高

一个子类不能直接继承多个父类，可让子类继承的一个父类去继承其他类来间接让子类继承其他类从而来达到一个子类继承多个父类
当子类自有的方法名和父类的方法名重名时，子类调用此方法就为子类的方法，如果想调用父类的方法，使用super.方法名

多态（前提：类有父子继承结构、子类重写父类关系）

              方法的参数是一个接口，方法的返回值也可以是一个接口（运行时多态）
              特点：
                      高聚合（把一个功能的所有方法都放在一个类里，对外暴露尽量少的方法，封装，隐藏细节）
                      低耦合（面向接口开发，参数由具体实现类）
             重载：一个类有多个方法，方法名相同，参数不同，也是多态体现（编译时多态）
             重写：方法重写，父子继承关系，子类重写覆盖父类的方法的内容

private、protected、private

             public修饰一个父类的方法，所有子类都能使用这个方法
             protected修饰一个父类的方法，只能在本工程里的子类使用这个方法，其他的工程不能使用这个方法
             private修饰一个父类的方法,只能本类使用这个方法，其他子类不能使用这个方法

单例：

          1.饿汉式单例：常规写法（Runtime 工具类）、静态代码块实现
          2.懒汉式单例：不是创建就初始化，在需要获取到对象时才初始化实例
             优点：不会反复创建对象，一旦创建对象，可以复用，性能高


饿汉类型一：

public class UniqueEH {
	//第一种饿汉式
	private static UniqueEH EH=new UniqueEH();
	private UniqueEH(){}
	private static UniqueEH getUniqueEH(){
		System.out.println("我是饿汉式实现单例[立即加载],static一开始就实例化对象,很占空间");
		return EH;
	}
		//饿汉式实现单例
	public static void main(String[] args) {
		for(int i=0;i<6;i++){
			UniqueEH s=UniqueEH.getUniqueEH();
			System.out.println(s);
		}
	}
	
}

饿汉类型二：

public class UniqueEH1 {
	//第二种饿汉式
	private static UniqueEH1 eh1=null;
	private UniqueEH1(){}
	static{
		eh1=new UniqueEH1();
	}
	private static UniqueEH1 getUniqueEH1() {
		return eh1;
	}
	
	public static void main(String[] args) {
		for(int i=0;i<6;i++){
			UniqueEH1 e=eh1.getUniqueEH1();
			System.out.println(e);
		}
	}
	
}

懒汉类型一：

public class UniqueLH {
	//第一种懒汉式
	private static UniqueLH	lh=null;
	private UniqueLH(){}
	public static UniqueLH getUniqueLH() {
		if(lh==null){
			System.out.println("我是懒汉式实现单例,static一开始没有实例化对象,用到时才实例化,比较节省空间");
			lh=new UniqueLH();
		}
		return lh;
	}
	
	public static void main(String[] args) {
		for(int i=0;i<7;i++){
			UniqueLH l=lh.getUniqueLH();
			System.out.println(l);
		}
	}
}

懒汉类型二：

public class UniqueLH1 {
	//第二种懒汉式
	private UniqueLH1(){}
		//懒汉式
	static class UniqueHolder{		//内部类
		private static final UniqueLH1 hl=new UniqueLH1();
	}
			
	private static UniqueLH1 getUniqueLH1(){
		return UniqueHolder.hl;
	}
	
	public static void main(String[] args) {
		for(int i=0;i<3;i++){
			UniqueLH1 h=UniqueHolder.hl.getUniqueLH1();
			System.out.println(h);
		}
	}
	
}

补充

             封装：体现高内聚，独立模块(安全、独有的功能)
             继承：代码复用，工作量小，修改一处，所有子类行为就都修改了.（缺点：破坏一定封装性，结合组合）
             多态：低耦合，把原来类之间关系，硬编码


             接口不能实例化
             抽象类不能实例化