Math类
- abs()——绝对值
- max(double a,double b)——a和b最大值
- min(double a,double b)——a和b最小值
- random()——产生0-1之间随机数
Date类
Date类用来表示日期和时间,该时间是一个长整形(long),精确到毫秒
- boolean after(Date when)——判断日期是否在指定日期之后 true/false
- boolean before(Date when)——判断日期是否在指定日期之前 true/false
- SimpleDateFormat——指定日期格式,格式化日期
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd"); System.out.println(simpleDateFormat.format(date));
年月日、时分秒
- compareTo()——比较
类之间的关系
- Object类是所有类的顶级父类
- 一个子类只能由一个直接父类,单一继承(extends)多次继承使用接口
- 涉及到金额用Bigdecimal,double慎用,易出现莫名其妙的错误
- 先调用父类的构造方法进行初始化,然后调用子类的构造方法进行初始化
- 多态——可以用子类对象赋值给父类对象
Product product=new Printer();
方法重写(override)——重写父类的方法
- 方法名及参数列表必须一致
- 返回值类型与父类保持一致,或是父类方法返回值类型的子类
- 子类方法声明的异常与父类保持一致,或是父类方法声明的异常的子类
- 父类的私有方法不能被子类重写,如果子类中定义了与父类重名的私有方法,则该方法只是子类的一个新方法,与父类中的私有方法无关
- 子类方法的可访问性必须与父类的可访问性保持一致,或是更加公开
- 不能重写静态方法
super关键字
- 在子类方法中访问父类的属性或方法——super.属性名/super.方法
final关键字
- 修饰变量——不可改变
- 修饰方法——不可被子类重写
- 修饰类——不可被子类继承
内部类
- 在一个类体之内再定义一个类——内部类/外部类
- 成员内部类/局部内部类/静态内部类/匿名内部类
匿名内部类
- 匿名内部类不能有构造方法
- 匿名内部类不能定义任何静态方法
单例模式
- 构造方法私有
- 用一个私有的静态变量引用实例
- 提供一个公有的静态方法实现
package Chapter0824;
//单例模式 SingletonDemo.java
class Singleton{
private static Singleton instance=null;
private Singleton(){
}
public static Singleton getInstance(){
//在第一次使用时生成了实例,提高了效率
if(instance==null){
instance=new Singleton();
}
return instance;
}
}
public class SingletonDemo {
public static void main(String[] args){
Singleton s1=Singleton.getInstance();
Singleton s2=Singleton.getInstance();
if(s1==s2){
System.out.println("s1和s2是一个对象。");
}
}
}
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
注意:
- 1、单例类只能有一个实例。
- 2、单例类必须自己创建自己的唯一实例。
- 3、单例类必须给所有其他对象提供这一实例。
一般用于数据库连接。
抽象类(abstract)
- 只有声明,没有方法
- 抽象类可以包含成员变量以及构造方法,但不能通过构造方法创建实例
package Chapter0824;
public abstract class Animal {
public String name;
public Animal(String name){
this.name=name;
}
// public Animal(){
//
// }
public String getName(){
return this.name;
}
public void setName(){
this.name=name;
}
//抽象方法,行动
public abstract void action();
//抽象方法,叫
public abstract void call();
//定义子类Horse和Bird类,继承Animal,并且实现action和call两个抽象方法
}
package Chapter0824;
public class Horse extends Animal{
public Horse(){
super("马");
}
@Override
public void action() {
System.out.println("冲啊");
}
@Override
public void call() {
System.out.println("嗷嗷");
}
}
package Chapter0824;
public class Bird extends Animal{
public Bird(){
super("鸟");
}
@Override
public void action() {
System.out.println("飞啊");
}
@Override
public void call() {
System.out.println("叽叽");
}
}
接口(implements)
- 降低各模块之间的耦合,提供可扩展性和可维护性
- 单一继承,不支持多重继承——通过接口来弥补
- Java允许一个类实现多个接口
- 一个接口继承(extends)多个接口时,多个接口之间使用“,”隔开
- 接口只能继承接口,不能继承类
- 访问符可以是public或缺省,如果缺省访问符,则默认采用包权限访问控制,即在相同包中才可以访问该接口
- 接口体内定义的方法——public,可省略
- 接口体内的变量——常量 static final 不可改变
package Chapter0824;
public interface Book {
int A=1;//public static final
void display();//public
}
package Chapter0824;
public class MathBook implements Book{
public MathBook(){
}
public void display() {
// Book.A=12;//final 不能改变
System.out.println("MathBook.");
}
public static void main(String[] args){
MathBook mathBook=new MathBook();
mathBook.display();
}
}
package Chapter0824;
public class ChineseBook implements Book{
public ChineseBook(){
}
public static void main(String[] args){
ChineseBook chineseBook=new ChineseBook();
chineseBook.display();
}
public void display() {
System.out.println("ChineseBook");
}
}
接口的继承
package Chapter0824;
public interface Book extends A,B,C{
int A=1;//public static final
void display();//public
}
- 接口和抽象类不能被实例化,需要被其他类实现或继承
- 接口和抽象类的类型变量都可以指向其实现类或子类的实例对象
- 接口和抽象类都可以包含抽象方法
接口和抽象类的区别
- 接口中定义的变量默认是public static final,且必须赋值,其实现类中不能重新定义,也不能改变其值,即接口中定义的变量都是最终的静态变量
- 接口中定义的方法都默认缺省的时public,而抽象类则与类一样默认是缺省的
- 一个类只能有一个直接父类
面向接口编程
简单工厂模式
instanceof
- 鉴别对象的真正类型
- 引用类型变量 instanceof 引用类型
- p instanceof People (返回Boolean类型)
- 用于判断前面的引用类型变量是不是后面的引用类型(子类、实现类的实例/类本身)
2018.8.24