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

包装类、代码块、单例模式、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里找不到
			
		}