包装类、object、单例模式、final、抽象类
/*包装类*/ /* byte Byte short Short int Integer long Long char Character float Float double Double boolean Boolean
基本数据和其包装类:作为成员变量时的默认初始值的差异: int -- Integer 0 null */ class WrapDemo { public static void main(String[] args) {
//包装类对象 /* 把基本数据类型包装类除了 Character类之外,其他的7个都有两个构造方法
基本数据类型xx; xx对应包装类的构造方法: public xx的包装类(xx x){} public xx的包装类(String x){}
这里传递的x值表示该包装类型对象的值; Integer i = new Integer(17);//i = 17 i = new Integer("123");// i = 123 使用第二种构造方法可能会引发 类型转换异常; Integer:凡是涉及到整数的操作,Integer类里都有相应的方法来处理;
Character类没有public Character(String c){}
*/ Boolean b = new Boolean("tRuE");//除了true之外(不区分大小写),其他的默认都是false
/* static Boolean FALSE 对应基值 false 的 Boolean 对象。 static Boolean TRUE 对应基值 true 的 Boolean 对象。
*/ b = Boolean.FALSE;//FALSE == new Boolean(false); System.out.println("b= " + b);
//十进制和 二进制,八进制,十六进制的转换
/* Integer: 有3个静态的方法可以完成: static String toBinaryString(int i) 以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。 static String toHexString(int i) 以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。 static String toOctalString(int i) 以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。 */ System.out.println(Integer.toBinaryString(-100)); //byte byteValue() 以 byte 类型返回该 Integer 的值。 Integer i = new Integer(17); byte by = i.byteValue(); System.out.println(by); /* int compareTo(Integer anotherInteger)在数字上比较两个 Integer 对象。 */
System.out.println(i.compareTo(new Integer(12)));//1 /* int intValue() 以 int 类型返回该 Integer 的值。
包装类 -->基本类型: 调用xxxValue(); int ret = age.intValue();
基本类型 -->其包装类
new 包装类(基本类型的值); new Integer(17); */
int age = i.intValue();
/* static int parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析。
String --> 基本类型 */ age = Integer.parseInt("17"); /* static Integer valueOf(int i) 基本类型 -->包装类类型 和 new Integer(int i); 返回一个表示指定的 int 值的 Integer 实例。 static Integer valueOf(String s) String --> Integer: new Integer(String s); 返回保存指定的 String 的值的 Integer 对象。
*/ //static boolean isDigit(char ch) 确定指定字符是否为数字。 //判断的是0 ~9之间的数字 System.out.println(Character.isDigit('A'));//false char c = '8';// System.out.println(Character.isDigit(c));
String s = "1214542S"; System.out.println("----------------"); int i1 = 12; int i2 = 12;
System.out.println(i1 == i2);//相等
Integer in1 = new Integer(12); Integer in2 = new Integer(12);
System.out.println(in1 == in2);//不相等的,两个对象
in1 = 12; in2 = 12; System.out.println("--->"+(in1 == in2));//true /* 这里涉及到了一个享元模式: 只缓存[-128,127]区间的数字,Byte,Short,Integer,Long 都是一样的 */ in1 = 128; in2 = 128; System.out.println("--->"+(in1 == in2));//true
/* 装箱和拆箱:
int Integer 装箱: 把基本数据类型 --> 它所对应的包装类类型 Integer i = new Integer(int value);
拆箱: 包装类类型 --> 它所对应的把基本数据类型 int i2 = i.intValue();
Java5开始提供了自动装箱和拆箱的功能; 自动装箱: 可以把一个基本数据类型的值直接赋给 其包装类对象 Integer age = 17;
Object就可以接受一切类型了; Object o = false; o = 123; 自动拆箱: 可以把一个包装类对象直接赋给一个基本数据类型的变量 int age2 = age;
*/
Integer age2 = 17;
int age3 = age2;
} }
class ObjectDemo { /* 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。 */ public static void main(String[] args) {
String[][] arr = {{"A"}};
Object o = arr; System.out.println(arr.getClass()); /* 常见方法:
boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。 equlas默认的比较的是 堆里地址,和 == 一样,都是比较地址
有的时候我们不需要比较地址,比如有的时候我们不关心地址,只关心值,咋办? 此时就要求子类去覆写该方法
比如Integer类: public boolean equals(Object obj) { if (obj instanceof Integer) { return this.value == ((Integer)obj).intValue(); } return false; }
int hashCode() 返回该对象的哈希码值。
String toString() 返回该对象的字符串表示。
*/
//equals
System.out.println(new Integer(1).equals(new Integer(1)));//true System.out.println(new Object().equals(new Object()));//false
System.out.println(new String() == new String());//false System.out.println(new String().equals(new String()));//true
System.out.println(new Object().hashCode());//每个对象的hashCode都会不一样 System.out.println(new Object().hashCode());
Object o1 = new Object();
System.out.println(o1.hashCode()); System.out.println(o1.hashCode()); /* String toString() 返回该对象的字符串表示 以字符串的形式描述了对象状态;//描述对象
hexHashCode 我们打印对象,其实打印的是对象的toString()方法 对象类型的全限定名 + @ + 对象十六进制的hashCode
一般情况下建议每个类都覆写toString()
对象 --> String
本质上打印对象,其实就是在打印对象的toString()方法 */ ObjectDemo od = new ObjectDemo(); System.out.println(od);//ObjectDemo@c05d3b System.out.println(od.toString());//ObjectDemo@c05d3b int hashCode = od.hashCode();// //static String toHexString(int i) 转16进制 String hexHashCode = Integer.toHexString(hashCode);
System.out.println(hexHashCode);
System.out.println(new Person("Will","男",17).toString()); System.out.println(new Person("Lucy","女",15));
Object p = new java.util.Date();
System.out.println("p.getClass()-->"+p.getClass().getName()); } }
class Person {
private String name; private String gender;
private Integer age; public Person(String name,String gender,Integer age) { this.name = name; this.gender = gender; this.age = age; } @Override//表示覆写 public String toString() { return "[ name= " + this.name +",性别= " + this.gender +", 年龄= " + this.age +"]"; } }
/*
普通代码块
*/
class CodeDemo1
{
public static void main(String[] args)
{
{
//普通代码块
int a = 10;
System.out.println("--->" + a);
}
//System.out.println(a);//访问不到
}
}
/* 构造代码块: 定义在 类里面,方法外面:
直接写在类中的代码块: 优先于构造方法执行，每次实例化对象之前都会执行构造代码块。 */ class CodeDemo2 {
public CodeDemo2(){ System.out.println("构造方法"); }
{ System.out.println("构造代码块"); }
public static void main(String[] args) { System.out.println("Main"); new CodeDemo2(); new CodeDemo2(); new CodeDemo2(); System.out.println("Hello World!"); } }
/* 静态代码块: 就是在构造代码块之前,加上一个 static关键字:
使用static 修饰的构造代码块: 优先于主方法执行，优先于构造代码块执行，不管有创建多少对象，静态代码块只执行一次，可用于给静态变量赋值； */
class CodeDemo3 {
static String name ;
public CodeDemo3() { System.out.println("构造方法!"); }
{ System.out.println("构造代码块!"); }
static { name = "AA"; System.out.println("静态代码块!"); } public static void main(String[] args) { System.out.println("Main!"); new CodeDemo3(); new CodeDemo3(); System.out.println("end"); } }
import java.lang.reflect.*;
class Cat { /* 使用private修饰构造方法之后,在该类之外的地方就不能再创建对象了. 结论不一定,因为要把反射除开;
//项目开发经常有这样的一个需求:
某一个对象,只需要存在一个就OK了; 有且只有一个对象;
古代皇帝,
*/ private Cat(){ //super(); System.out.println("cat"); } }
class PrivateDemo {
public static void main(String[] args) throws Exception { Class<Cat> clz = Cat.class; //得到class对象的三种方式之一
Constructor<Cat> c = clz.getDeclaredConstructor();//得到私有私有的构造函数 c.setAccessible(true);//暴力反射 -- 私有的东东就可以在外部进行访问了 Cat cat = c.newInstance();//实际上是调用类里面的无参构造方法创建对象
System.out.println(cat); } }
/* 单例模式: 保证整个项目运作期间某一个对象有且只有一个;
单例模式: 1.饿汉式 2.懒汉式 */
class Singleton { //饿汉式----每次调用的时候不用做创建，直接返回已经创建好的实例。这样虽然节省了时间，但是却占用了空间，实例本身为static的，会一直在内存中带着 private static final Singleton instance;// = new Singleton();
static { instance = new Singleton(); } public static Singleton getInstance() { return instance; } //把构造方法私有化,不允许外界再创建对象 private Singleton(){} }
class Singleton2 { //懒汉式 懒汉式则是判断，在用的时候才加载，会影响程序的速度 ,线程不安全的在并发的情况下。如果两个线程，我们称它们为线程1和线程2，在同一时间调用getInstance()方法，如果线程1先进入if块，然后线程2进行控制，那么就会有两个实例被创建。 private static Singleton2 instance = null; public static Singleton2 getInstance() { if(instance == null) { instance = new Singleton2(); }
return instance; } private Singleton2(){} }
class SingletoDemo { public static void main(String[] args) { // Singleton s1 = Singleton.instance; // Singleton s2 = Singleton.instance;
Singleton s1 = Singleton.getInstance(); Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
Singleton2 s3 = Singleton2.getInstance(); Singleton2 s4 = Singleton2.getInstance();
System.out.println(s3 == s4); } }
final class FinalCLass { }
//class Sub extends FinalCLass {} //FinalDemo.java:5: 错误: 无法从最终FinalCLass进行继承
class Super { //修饰符没有先后关系 final public void show() { } }
class Sub extends Super { //FinalDemo.java:20: 错误: Sub中的show()无法覆盖Super中的show() /**public void show() { } */ }
class FinalDemo { //全局常量 public static final int MAX_VALUE = Integer.MAX_VALUE; public static void main(String[] args) { /* final修饰的变量表示常量: 对常量有一个规范小规定:常量名得全部大写 若该常量名由多个单词组成, 单词字符全部写,而且单词于单词之间使用下划线分割;
public static final int MAX_VALUE
final修饰的变量不能赋值? 最多只能赋值一次,一旦有值之后就不能被修改了;
面试题: 当final修饰一个引用类型变量的时候, 那到底是引用不能变(引用地址不能变),还是引用对象的值不能变呢?
答: 是引用的地址不能变,对象里的内容是可以变的; */
final double PI = 3.14; //pi = 0.618;//FinalDemo.java:38: 错误: 无法为最终变量pi分配值
System.out.println(PI); //说明地址不能变 final String s = new String(); //s = new String();//FinalDemo.java:59: 错误: 无法为最终变量s分配值
//地址不变,但是对象内容的
final StringBuilder sb = new StringBuilder("AAA");//字符串 System.out.println(sb);
sb.append("BBB");//追加 System.out.println(sb);
} }
abstract class OOXX { } /*
抽象方法: 使用abstract修饰的方法,但是没有方法体(没有{}),只有方法声明,抽象方法强制子类覆写
一旦一个类有了抽象方法,那么该类也必须声明为抽象类; 但是抽象类可以没有抽象方法;
抽象类不能实例化,不能创建对象
抽象类必须得有子类,自己的功能才能得以运行;
抽象类的方法只是定义了子类应该具备的行为, 但是没有给出怎么去完成行为的功能代码; 交给子类去根据自身特殊情况去完成该父类声明的功能;
抽象方法也成为 钩子方法; 回调方法
抽象类里可以有普通方法,
抽象类是类的一种特殊情况:据有类的一切特点,但是 不能实例化; 一般的都得带有抽象方法 */
abstract class Tuxing { //建议写在方法的最前面,为了醒目 abstract public double getZC();
public Tuxing(){ // System.out.println("---"); } }
class Sanjiaoxing extends Tuxing { private double a; private double b; private double c; public Sanjiaoxing(double a,double b,double c) { this.a = a; this.b = b; this.c = c; }
//必须覆写 public double getZC(){
//new Tuxing();//ERROR return a + b + c; }
}
//矩形 class Juxing extends Tuxing {
public Juxing() {
super(); } //忘了覆写 public double getZC(){ //new Tuxing();//ERROR return 0; }
} class AbstractDemo2 { public static void main(String[] args) { double ret = new Sanjiaoxing(3,4,5).getZC();//AbstractDemo2.java:35: 错误: Sanjiaoxing是抽象的; 无法实例化 System.out.println(ret); } }
