1.继承:
java只允许多层继承,不允许多重继承
被覆写的方法权限范围不能比父类中的小,父类中的private方法不能被覆写。
实例化子类时,可以理解为子类构造方法中有super()方法,先实例化父类对象在实例化
子类对象,父类是抽象类也是一样的(抽象类也可以含有构造方法,必须要通过子类实例化本类
对象)
final修饰的变量就是常量,常量不能被改变。
final修饰方法不能被覆写
final修饰的类不能被继承
抽象类:abstract
可以含有构造方法,抽象方法,普通方法,常量,变量
抽象类也可以含有构造方法,必须要通过子类实例化本类对象
抽象类中不一定要有抽象方法,但是含有抽象方法的类一定是抽象类
抽象类中的抽象方法必须要被覆写
抽象方法不要用private修饰显然
抽象类可以不实现接口的方法,由抽象类的子类实现
接口:interface
含有全局常量,抽象公共方法
接口中的方法都是抽象方法,权限永远是public就算没写也默认为public而不是default
实现接口的类必须实现所有的抽象方法
多态性:
向上转型向下转型
一个对象进行向下转型时,这个对象必须首先发生向上转型,否则会出现类型转换异常
a instance of A的使用
比较a对象是否为A类的一个实例
永远不要去继承一个已经实现好的类,只能继承抽象类或者实现接口,因为一旦发生
对象向上转型关系以后,所调用的方法一定是被子类所覆写过的方法。
工厂设计模式:
interface Fruit {
public void eat();
}
class Apple implements Fruit {
public void eat() {
System.out.println("吃苹果ing");
}
}
class Orange implements Fruit {
public void eat() {
System.out.println("吃橘子ing");
}
}
class Factory {
public static Fruit getInstance(String s) {
Fruit f = null;
if ("apple".equals(s)) {
f = new Apple();
}
if ("orange".equals(s)) {
f = new Orange();
}
return f;
}
}
public class Demo {
public static void main(String[] args) {
Fruit f = null;
f = Factory.getInstance("apple");
f.eat();
}
}
代理设计:
interface NetWork {
public void browse();
}
class real implements NetWork {
public void browse() {
System.out.println("上网中...");
}
}
class Proxy implements NetWork {// 代理类
real l = new real();
public void check() {
System.out.println("上网账号密码输入正确,登陆中...");
}
public void browse() {
this.check();
l.browse();
}
}
public class Demo2 {
public static void main(String[] args) {
NetWork n = new Proxy();
n.browse();
}
}
适配器设计:
interface Windows {
public void open();
public void close();
public void activted();
public void smaller();
}
abstract class Window implements Windows {// 适配器
public void open() {
};
public void close() {
};
public void activted() {
};
public void smaller() {
};
}
class Windowtest extends Window {
public void close() {
System.out.println("窗口关闭...");
}
}
public class Demo3 {
public static void main(String[] args) {
Windows win = new Windowtest();
win.close();
}
}
java只允许多层继承,不允许多重继承
被覆写的方法权限范围不能比父类中的小,父类中的private方法不能被覆写。
实例化子类时,可以理解为子类构造方法中有super()方法,先实例化父类对象在实例化
子类对象,父类是抽象类也是一样的(抽象类也可以含有构造方法,必须要通过子类实例化本类
对象)
final修饰的变量就是常量,常量不能被改变。
final修饰方法不能被覆写
final修饰的类不能被继承
抽象类:abstract
可以含有构造方法,抽象方法,普通方法,常量,变量
抽象类也可以含有构造方法,必须要通过子类实例化本类对象
抽象类中不一定要有抽象方法,但是含有抽象方法的类一定是抽象类
抽象类中的抽象方法必须要被覆写
抽象方法不要用private修饰显然
抽象类可以不实现接口的方法,由抽象类的子类实现
接口:interface
含有全局常量,抽象公共方法
接口中的方法都是抽象方法,权限永远是public就算没写也默认为public而不是default
实现接口的类必须实现所有的抽象方法
多态性:
向上转型向下转型
一个对象进行向下转型时,这个对象必须首先发生向上转型,否则会出现类型转换异常
a instance of A的使用
比较a对象是否为A类的一个实例
永远不要去继承一个已经实现好的类,只能继承抽象类或者实现接口,因为一旦发生
对象向上转型关系以后,所调用的方法一定是被子类所覆写过的方法。
工厂设计模式:
interface Fruit {
public void eat();
}
class Apple implements Fruit {
public void eat() {
System.out.println("吃苹果ing");
}
}
class Orange implements Fruit {
public void eat() {
System.out.println("吃橘子ing");
}
}
class Factory {
public static Fruit getInstance(String s) {
Fruit f = null;
if ("apple".equals(s)) {
f = new Apple();
}
if ("orange".equals(s)) {
f = new Orange();
}
return f;
}
}
public class Demo {
public static void main(String[] args) {
Fruit f = null;
f = Factory.getInstance("apple");
f.eat();
}
}
代理设计:
interface NetWork {
public void browse();
}
class real implements NetWork {
public void browse() {
System.out.println("上网中...");
}
}
class Proxy implements NetWork {// 代理类
real l = new real();
public void check() {
System.out.println("上网账号密码输入正确,登陆中...");
}
public void browse() {
this.check();
l.browse();
}
}
public class Demo2 {
public static void main(String[] args) {
NetWork n = new Proxy();
n.browse();
}
}
适配器设计:
interface Windows {
public void open();
public void close();
public void activted();
public void smaller();
}
abstract class Window implements Windows {// 适配器
public void open() {
};
public void close() {
};
public void activted() {
};
public void smaller() {
};
}
class Windowtest extends Window {
public void close() {
System.out.println("窗口关闭...");
}
}
public class Demo3 {
public static void main(String[] args) {
Windows win = new Windowtest();
win.close();
}
}