疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

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里找不到

  }