注意:
1.System.out.println(1 + new Person("abc")); //出错
2.equals()的重写实例:
@Override
public boolean equals(Object obj) { //形参是Object类型,必须在下面使用向下转型才能使用子类的特有方法,使用instanceof进行辅助检查,达到最后的比较目的
if(this == obj)
return true;
if(obj instanceof Person) {
Person p = (Person)obj;
if(this.name==null && p.name==null) {
return this.age==p.age;
}
if(this.name!=null) {
return this.name.equals(p.name) && this.age==p.age;
}
}
return false;
}
3.System.currentTimeMillis(); //打印:当前时间距离1970年的间隔时间的毫秒数!!!
一.Object类
1.java.lang.Object类:
Object是Java中所有类的父类, 一个类如果不继承任何类, 那么默认继承Object
Object类中的所有方法都会被子类继承
2.toString()方法
a.在println或者print方法中打印一个对象的时候, 默认会调用该对象的toString方法, 然后将返回值显示到屏幕
如:
Person p = new Person("abc");
System.out.println(p.toString());
System.out.println(p);
b.toString方法在Object类中默认返回的是"类名@地址"的形式
注:
getClass().getName()+"@"+Integer.toHexString();
c.如果我们不想返回上面的形式, 可以在类中重写toString方法, 通常我们重写后都是返回该类的属性
如:
@Override
public String toString() {
return this.name+" ,"+this.age;
}
d.把一个对象和一个String用"+"做运算的时候, 会调用该对象的toString方法先转为String再相加
如:
System.out.println(1 + new Person("abc")); //出错
System.out.println(new Person("abc") +1 ); //正确
System.out.println("1" + new Person("abc")); //正确
3.equals()方法:
a."=="与equals()的区别:
如:
String s1="abc";
String s2="abc";
System.out.println(s1 == s2); // true
System.out.println(s1.equals(s2)); // true
String s3=new String("abc");
String s4=new String("abc");
System.out.println(s3 == s4); // false
System.out.println(s3.equals(s4)); // false
b.equals():
比较两个对象是否相同(内容相同),比较字符串的时候, 如果我们希望比较两个字符串的内容是否相同, 那么就可以使用equals方法
我们调用equals方法比较两个对象, 会先在当前类找是否有equals方法, 如果没有就会找Object类, Object类的equals默认是比较地址.
c.如果我们不想比较地址, 希望按照对象的属性来比较, 就可以重写该方法. String类的equlas方法可以比较String的内容, 就是因为重写了该方法.
如:
class Person {
private String name;
private int age;
public Person(String name,int age) {
this.name=name;
this.age=age;
}
@Override
public boolean equals(Object obj) { //形参是Object类型,必须在下面使用向下转型才能使用子类的特有方法,
//使用instanceof进行辅助检查,达到最后的比较目的
if(this == obj)
return true;
if(obj instanceof Person) {
Person p = (Person)obj;
if(this.name==null && p.name==null) {
return this.age==p.age;
}
if(this.name!=null) {
return this.name.equals(p.name) && this.age==p.age;
}
}
return false;
}
}
二.文档注释:
1.格式:
/**
*
*/
2.实例:
/**
*这是一个Person类.<br>用于创建Person对象.
*其是一个带名称属性的对象.
*@author Liu
*@version 1.0
*@since 1.8
*/
public class Person { //必须类使用public修饰
/**
*Person的名称属性.
*/
private String name;
/**
*Person的构造函数.需要传递一String参数.
*@param name-创建Person对象的名称
*/
public Person(String name) {
this.name=name;
}
/**
*重写了Object类的toString()方法.
*@return 返回当前Person对象的名称的字符串.
*/
@Override
public String toString() {
return this.name;
}
}
3.CMD编译生成命令:
javadoc -d . -author -version Person.java
三.组合设计模式-CompositePattern
1.什么是组合设计模式
在定义一个类的时候, 需要使用另一个类的功能时, 可以使用组合设计模式
2.组合设计模式的写法
a.用构造函数接收要组合的对象
b.定义成员变量, 记住组合进来的对象
c.通过成员变量, 调用被组合对象的方法
注:
class CompositeDemo {
public static void main(String[] args) {
Card c = new CreditCard();
Person p = new Student(c);
p.shopping();
p.eat();
}
}
class Person { // 人
private Card card; // 2.定义成员变量, 记住组合进来的对象
public Person(Card card) { // 1.用构造函数接收要组合的对象
this.card = card;
}
public void shopping() { // 购物
card.spend(); // 3.通过成员变量, 调用被组合对象的方法
System.out.println("买了一台iPhone5");
}
public void eat() {
card.spend();
System.out.println("吃了一顿全聚德");
}
}
class Student extends Person {
public Student(Card card) {
super(card);
}
}
class Card { // 卡
public void spend() { // 刷卡
System.out.println("刷卡消费, 一不小心刷了100块!");
}
}
class CreditCard extends Card {
public void spend() { // 刷卡
System.out.println("刷卡消费, 先欠着!");
}
}
3.组合和继承的区别或优点:
a.组合设计模式不占用继承位置
b.在只是需要调用, 而没有逻辑上的父级关系时, 不合适用继承
四.多态-polymorphism
1.什么是多态
多态就是一段代码可以运行出多种形态
2.怎么实现多态
在定义方法的时候, 形参可以指定为父类类型, 这样所有的子类对象也可以传入, 传入不同的子类对象, 就可以调用不同的方法. 代码就实现了多种形态.
五.抽象类 (注: abstract 只修饰类和方法!!)
1.什么是抽象类
a.用abstract关键字修饰的类就是抽象类
b.抽象类中可以定义抽象方法
c.抽象类不能创建对象
2.怎么定义抽象类
子类中方法声明和实现都相同的方法: 在父类中声明, 直接实现.
子类中方法声明相同, 实现不同的方法: 在父类中声明为抽象方法, 子类中实现
3.为什么定义抽象类
a.有时候多个类中具有相同的方法声明, 而实现方式不同, 我们就可以在父类中定义一个抽象方法, 在子类中实现
b.父类中还可以将子类中相同的方法定义出来, 这样提高代码复用性.
c.父类中声明了抽象方法, 虽然没有实现, 但是在子类当作父类来用时, 通过父类变量也能调用到子类的方法, 更好的支持了多态
d.在别人阅读我们的代码时, 看到了抽象类, 就知道子类都有哪些方法.
4.抽象类的继承
a.一个抽象类可以继承另一个抽象类
b.一个普通的类如果继承抽象类, 那么所有的抽象方法必须重写后,才能创建子类对象,否则子类必须使用abstract修饰
c.抽象类中可以没有抽象方法, 目的就是为了不让别人创建对象, 专门为了给别人继承来用的. GUI中一些Adapter就是这样的抽象类.
六.final关键字
1.类: 最终的类, 不能被继承
2.方法: 最终的方法, 不能被重写
3.变量: 最终的变量, 就是常量, 只能赋值一次.
a.可以用在局部变量, 成员变量, 形参
b.实际应用: public static final double PI = 3.1415;
注:
final int x=4; //x的生命周期,是在程序运行完成后结束!!
七.模板设计模式
1.什么时候用模板设计模式
在多段代码中有一些代码重复使用的时候,
2.怎么使用:
a.将重复的代码写在一个模板方法中, 不确定的代码定义成一个抽象方法.
b.在模板方法中调用抽象方法.
c.定义子类继承该类, 重写抽象方法, 写入不同的代码即可, 原来相同的代码可以从父类继承到, 不用重新再写
注:
class TemplateDemo {
public static void main( String ... args){
new A().test();
}
}
abstract class Template {
public final void test() {
long start=System.currentTimeMillis();
System.out.println(start);
doSomething();
long end=System.currentTimeMillis();
System.out.println(end-start);
}
abstract void doSomething();
}
class A extends Template {
@Override
public void doSomething() {
//code
for(int i=0;i<1000;i++) {
System.out.println(i);
}
}
}