JAVA第三周

面对对象-多态

hashCode&equals

• hashCode表示引用对象在堆内存的存储地址
• equals比较时，必须保证两个对象的hashCode地址是一致的，重写对象的equals时必须要同时重写hashCode。

多态

• 行为的多态（一种方法以多种不同的形式呈现）
  方法的重写、方法的重载
• 变量的多态
  父类的引用指向子类对象、子类引用指向父类对象

多态的好处

• 提高程序的可拓展性
• 提高代码的可复用性
• 提高程序的可维护性

拆箱装箱

• 装箱 ：将基本类型的值包装成为对应的引用类型对象

Integer i = 10;

• 拆箱 ：将封装类型中的基本数据拆成为基本数据类型

int n = new Integer(10);

String

String用于表示定义一个定长字符串，不适合做大量的字符串拼接。（大量字符串拼接需求，建议StringBuffer&&StringBuilder）

public static void main(String[] args) {
	String s = "ABCDEFGHIJKLMN";
		for(int i = 0;i<s.length();i++) {
		System.out.print( Integer.toHexString(s.charAt(i))+" ");
		}
		//将字符串以16进制显示	
	}

public static void main(String[] args) {
		CommonsDome cd = new CommonsDome();
		String commons = "听说凤姐去了米国，找到了心仪男票，三天两头在微博上抨击单身狗。。。。";
		String [] i = {"凤姐","男票","单身狗"};
		
		for(int z = 0;z<i.length;z++) {
			commons = commons.replace(i[z],"*");
		}
		System.out.println(commons);
		//将"凤姐"、"男票"、"单身狗"用*号代替
	}

StringBuffer&StringBuilder

• StringBuffer是线程安全的。
• StringBuilder是线程不安全的，在多线程环境在效率要高于Buffer，因为Buffer的方法中都有同步锁，因此在多线程访问的时候，同一时间只能有一条线程访问方法，单线程环境下两者的效率是一致的

static

• 被static修饰的属性为静态属性
• 被static修饰的方法为静态方法
• 被static修饰的初始化块为静态游离块

1. 被static修饰的元素不在与对象有关
2. static一般用于工具类
3. 不能在静态方法中调用非静态成员
4. 不允许态static方法中使用this关键字

Math类

//获取圆周率
System.out.println(Math.PI);

//向上取整
System.out.println(Math.ceil(10.001));//11
//向下取整
System.out.println(Math.floor(10.999));//10
//随机数
System.out.println(Math.random());//随机的是0~0.999的double类型
//求一个数的n次幂
System.out.println(Math.pow(2,4));//2的4次方

设计模式-单列模式

在程序运行的过程中始终只存在一个对象

public class Student2 {
	private static Student2 student = new Student2();
	
	private Student2() {
		// TODO Auto-generated constructor stub
	}
	public static Student2 student() {
		return student;
	}
}
//类加载时就创建实列对象，以时间换空间

Runtime类

与本机系统互交的类

public class TestRuntime {
	public static void main(String[] args) throws IOException {
		//获取与当前系统环境交互的运行时对象
		Runtime rt = Runtime.getRuntime();
		//返回jvm中可用的内存空间
		long t = rt.freeMemory();
		System.out.println(t/(1024*1024));
		rt.exit(0);
		//电脑关机 定时关机
		rt.exec("shutdown -s -t 300");
		//打开控制面板
		rt.exec("control");
		//打开计算器
		rt.exec("mspaint");
		//启动应用程序
		rt.exec("C:\\Program Files(X86)\\.......");
	}
}

final关键字

• final修饰的类无法被继承
• final修饰属性一旦被赋值则无法修改
• final修饰的方法无法被重写
  final在修饰类时一般表示该类就已经时最终的实现，不能在进行扩展，final在修饰属性时一般会结合static共同使用。

抽象类（abstract class）

抽象类中内部成分由 -属性 -构造器 -行为

public abstract class name{
	//属性
	//方法
	public abstract int age(int i);
}

特点

1. 抽象类必须使用阿布abstract修饰
2. 抽象类存在构造器，但是无法实列化
3. 抽象类中通常会包含抽象方法
4. 抽象类的存在一般是需要由子类继承，子类一旦继承了抽象类，则子类必须实现父类中的抽象方法
5. 抽象类中允许继承其他抽象类，但是也只能单继承，可以通过多重继承的方法实现多继承
6. abstract只能修饰类和方法

接口（interface）

• 接口不存在构造器，因此无法实列化
• 接口允许继承接口，可以同时继承多个接口
• 一个类可以实现多个接口，但是必须要同时实现所有接口的方法（除非抽象类）
• 抽象类也实现接口

public interface 接口名称{
//常量定义
//方法的声明(不含实现)
}

抽象类和接口的区别

• 抽象类是一种类结构，接口时一种行为准则
• 抽象类中包含类的所有特征，同时包含抽象方法；接口只能有常量和未实现的方法
• 抽象类由子类通过extends进行拓展；接口由实现类通过 implements拓展
• 子类只能继承一个抽象类；一个类可以实现多个接口
• 抽象类能且只能继承一个父类；接口可以继承多个接口，接口不能继承任何类
• 抽象类是对类的一种抽象；接口是对行为的抽象，接口是一种特殊的抽象类

多态(polymorphism)

多态的体现包含两种层面:

1. 方法层面（重写和重载）
2. 属性层面

• 父类引用指向子类对象
• 子类引用指向父类对象

多态也称之为动态绑定：在运行期间动态为引用变量绑定具体的对象数据

内部类

通常一个java文件中只能包含一个public class ， 但是可以在一个java类的内部中嵌套其他的java类(内部类)

public class People{
	public void m(){
	
	}
	public static void main(String[] args){
	}
	//内部类
	class Body{
	}
}

Timer & TimerTask

//定时任务类
public class MyTask extends TimerTask{
public void run(){
	System.out.println("执行任务。。。。");
}
}
//测试类
public class TestTimer{
public static void main(String[] args){
	//1秒 = 1000毫秒
	//创建一个定时器
	Timer t = new Timer();
	//多态
	t.schedule(new MyTask(),5000,1000);
}
}