Java类额应用

基本数据类型包装类
  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;
  }
 }
 
 public static void mian (String []args)
 {
  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("一根一根的吃");
   }
  }
  
  class  NormalMan extends Person
  {
   void eat()
   {
    System.out.println("一口一口的吃");
   }
  }
  
  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里找不到
  }