包装类、代码块、单例模式、Final、抽象类

  

   

    

     

    
    

     

      	基本数据类型包装类
     
    
   

    

     

    
    

     

      		Integer    Character
     
    
   

    

     

    
    

     

      		其他的都是将首字母大写;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	包装类和基本类型之间的转换:
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	Integer   int
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	Integer i = new  Integer(int value);
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	int i2 = i.intValue();
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	基本数据类型和String转换
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	String -->int
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	static int parseInt(String s) 
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	int i = Integer.parseInt("123");
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	int ->String
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	String 类valueOf(int val);
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	String str = String.valueOf(123);
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	装箱和拆箱:
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	java5开始出现自动装箱和拆箱;
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	自动装箱:
     
    
   

    

     

    
    

     

      			可以直接把一个基本数据类型的值直接赋给它所对应的包装类对象;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			Integer i = 17;
     
    
   

    

     

    
    

     

      	自动拆箱:把包装类对象直接赋给它所对应的基本类型的一个变量
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
			int i2 = new Integer(2);
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			Object是所有类的超级父类,
     
    
   

    

     

    
    

     

      			Object的对象可以接受一切数据;
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      		享元模式:	
     
    
   

    

     

    
    

     

      			Byte,Short,Integer,Long缓存了一个区间的数据;[-128,127]看源代码
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			Integer i1 = 123;
     
    
   

    

     

    
    

     
			Integer i2 = 123;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			i1 == i2;//true
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			new Integer(123) == new Integer(123);//false
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	Object类:就是描述对象的一个类
     
    
   

    

     

    
    

     

      		是超级父类;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		可以接受一切数据,包括数组;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		Object o = {1,2,3};
     
    
   

    

     

    
    

     
		Object o = new int[]{1,2,3};
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
	boolean equals(Object otherObj);
     
    
   

    

     

    
    

     

      		就是那当前对象和otherObj相比较;
     
    
   

    

     

    
    

     

      		默认情况下,比较的是  内存里的地址,此时和 == 一样;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		一般要求子类根据自身情况覆写该方法,
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		String 类覆写  equals方法
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		Integer  类也覆写了 equals方法
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	int hashCode();//返回对象的一个十进制的hash值,每个对象的hashCode都不一样
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	String toString();//把对象转成String类型, 描述对象信息
     
    
   

    

     

    
    

     

      		默认情况下,  类的全限定名 + @ + Integer.toHexString(this.hashCode());
     
    
   

    

     

    
    

     

      		一般要求子类覆写该方法
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		平时我们打印对象,其实打印的是对象的toString方法,也就说在底层该对象会去调用toString方法
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
	class Person{
     
    
   

    

     

    
    

     

      		String name;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		int age;
     
    
   

    

     

    
    

     
		public Person(String name,int age)
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			this.name = name;
     
    
   

    

     

    
    

     
			this.age   = age;
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		public String toString()
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			return this.name +", " + this.age;
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     

      	..main..
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     

      		System.out.println(new Person("Will",17));
     
    
   

    

     

    
    

     

      		System.out.println(new Person("Lucy",16));
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	代码块:
     
    
   

    

     

    
    

     
		1.普通(局部)代码块,写在方法;
     
    
   

    

     

    
    

     
		2.构造代码: 类里面,方法外面, 特点: 先于构造方法的执行,每次创建对象,都会执行
     
    
   

    

     

    
    

     
		3.静态代码块:  static 修饰的构造代码块, 特点: 优先于主方法的执行，优先于构造代码块执行,只执行一次,  可以用来给静态变量赋值;
     
    
   

    

     

    
    

     
		4.同步代码块 
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	单例模式:
     
    
   

    

     

    
    

     

      		保证项目中的一个类在运行期间有且只有一个实例对象;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			//1. 把构造方法给私有化,保证外界不能创建对象
     
    
   

    

     

    
    

     
			//2. 自身在内部先创建一个对象,再使用private修饰起来,
     
    
   

    

     

    
    

     
			//3. 向外暴露一个全局的静态的方法用于返回内部创建的对象;
     
    
   

    

     

    
    

     

      						因为静态成员只能访问静态成员,那么此时必须把对象使用static修饰,
     
    
   

    

     

    
    

     

      			饿汉式:	
     
    
   

    

     

    
    

     
					
     
    
   

    

     

    
    

     
					class Singleton
     
    
   

    

     

    
    

     

      					{
     
    
   

    

     

    
    

     
						private Singleton(){}
     
    
   

    

     

    
    

     
						
     
    
   

    

     

    
    

     
						private static final Singleton instance = new Singleton();
     
    
   

    

     

    
    

     
						//线程安全
     
    
   

    

     

    
    

     
						public  static Singleton getInstance()
     
    
   

    

     

    
    

     

      						{
     
    
   

    

     

    
    

     
							return instance;
     
    
   

    

     

    
    

     

      						}
     
    
   

    

     

    
    

     

      					}
     
    
   

    

     

    
    

     
					
     
    
   

    

     

    
    

     
					
     
    
   

    

     

    
    

     

      			懒汉式:	
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
					class Singleton
     
    
   

    

     

    
    

     

      					{
     
    
   

    

     

    
    

     
						private Singleton(){}
     
    
   

    

     

    
    

     
						
     
    
   

    

     

    
    

     
						private static final Singleton instance = null;
     
    
   

    

     

    
    

     
						
     
    
   

    

     

    
    

     
						//线程不安全的
     
    
   

    

     

    
    

     
						public  static Singleton getInstance()
     
    
   

    

     

    
    

     

      						{	
     
    
   

    

     

    
    

     
							if(instance == null)
     
    
   

    

     

    
    

     

      							{
     
    
   

    

     

    
    

     

      								instance = new Singleton()
     
    
   

    

     

    
    

     

      							}
     
    
   

    

     

    
    

     
							return instance;
     
    
   

    

     

    
    

     

      						}
     
    
   

    

     

    
    

     

      					}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		final:
     
    
   

    

     

    
    

     

      			表示最终的;
     
    
   

    

     

    
    

     

      			可以修饰 类,方法,变量;
     
    
   

    

     

    
    

     
			final 修饰的类 表示太监类,不能被继承;基本数据类型包装类全是
     
    
   

    

     

    
    

     
			final 修饰的方法 表示 不能被子类覆写 ;
     
    
   

    

     

    
    

     
			final 修饰的变量:
     
    
   

    

     

    
    

     

      					常量: 常量名大写,若是多个单词组成,单词之间使用下划线隔开;
     
    
   

    

     

    
    

     

      					全局常量: public static final 修饰的变量
     
    
   

    

     

    
    

     
					
     
    
   

    

     

    
    

     

      					常量只能赋值一次
     
    
   

    

     

    
    

     
					
     
    
   

    

     

    
    

     

      					若是引用类型的常量,表示 引用对象的地址不能变,但是对象的内容是可以改变的;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			方法里的内部类,只能访问方法里使用 final 修饰的变量;
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	抽象类:
     
    
   

    

     

    
    

     

      		使用 abstract 修饰的类,  一般抽象类都应该包含抽象方法,但不是必须的;
     
    
   

    

     

    
    

     

      		若一个类有抽象方法,那么该类必须是抽象类;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		不能创建对象(不能 new),其他的换个普通类一样
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		可以包含普通方法;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		什么时候使用抽象方法:
     
    
   

    

     

    
    

     

      			父类定了子类应该具备的行为,但是 具体行为的实现必须得有子类来完成;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      		抽象方法:
     
    
   

    

     

    
    

     

      			使用 abstract 修饰的方法, 
     
    
   

    

     

    
    

     

      				只有方法的申明,没有方法的具体实现;(交给子类去实现)
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      				一般建议把 abstract 放在修饰符前面;
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      		抽象类必须有子类,
     
    
   

    

     

    
    

     

      		而且子类必须全部覆写抽象类中的抽象方法,二者,子类也作为抽象类;
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      		青年(Person)都有吃饭(eat)和坐(set)的行为；
     
    
   

    

     

    
    

     

      		但是文艺青年(ArtMan)和普通青年(NormalMan)各自的的吃饭和坐的行为的具体表现都不一样；
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		abstract class Person{
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			abstract void eat();
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			abstract void set();
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		class ArtMan extends Person{
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			void eat(){
     
    
   

    

     

    
    

     

      				System.out.println("一根一根的吃");
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			void set(){
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		class  NormalMan extends Person
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			void eat(){
     
    
   

    

     

    
    

     

      				System.out.println("一口一口的吃");
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			void set(){
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		class  B2 extends Person
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			void eat(){
     
    
   

    

     

    
    

     

      				System.out.println("一坨一坨的吃");
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			void set(){
     
    
   

    

     

    
    

     

      				System.out.println("腿搅成麻花儿");
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			void show(){System.out.println("腿搅成麻花儿");
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		...mian..
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
				Person p = new B2();
     
    
   

    

     

    
    

     

      				p.eat();//实际调用的是B2里的方法
     
    
   

    

     

    
    

     

      				p.set();
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     
				//p.show();//编译通不过,在Person里找不到
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
	
     
    
  
 

文章来源: brucelong.blog.csdn.net，作者：Bruce小鬼，版权归原作者所有，如需转载，请联系作者。

原文链接：brucelong.blog.csdn.net/article/details/81625795