/**
* 抽象类：很多具有相同特征和行为的类可以抽象为一个抽象类
* 1.抽象类可以没有抽象方法，有抽象方法的类必须是抽象类
* 2.非抽象类继承抽象类必须实现抽象方法【可以是空实现】
* 3.抽象类可以有方法和属性
* 4.抽象类不能被实例化
* 5.抽象类不能声明为final
* 6.抽象类可以有构造方法【不代表实例化对象】
*/
public class Main {
public static void main(String[] args) {
Goddess m1 = new Goddess();
m1.setName("dining");
m1.say();
Ugly m2 = new Ugly();
m2.setName("fish");;
m2.say();
}
}
abstract class Woman{ //Woman为抽象类
private String name;
public Woman(){
System.out.println("我是抽象类的构造方法。");
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public abstract void say(); //抽象方法（只有声明，没有实现）
}
class Goddess extends Woman{
//实现父类的抽象方法
public void say(){
System.out.println("我是女神，我的名字是："+getName());
}
}
class Ugly extends Woman{
public void say(){
System.out.println("我是丑女，我的名字是："+getName());
}
}
/**
* 接口：一组行为的规范、定义，没有实现
* 接口定义格式：
* interface 接口名称{
* 全局常量;
* 抽象方法;
* }
* 1.一个类可以实现多个接口
* 2.抽象类实现接口可以不实现方法
* 3.接口中所有方法的访问权限都必须是public
* 4.接口中定义的属性都是常量
*/
//定义一个接口
interface Hit{
public static final String NAME = "d"; //在接口中定义的属性都是常量 public static final都可以省略
public void cry(); //抽象方法 public abstract(可以省略)
}
interface IEat{
public void eat();
}
class goddess implements Hit,IEat{
//实现接口必须实现接口中的所有方法
public void cry(){
System.out.println("疼死我了~");
}
public void eat(){
System.out.println("一小口一小口吃~");
}
}
class girl implements Hit{
public void cry(){
System.out.println("你妹啊！疼死老娘了~");
}
}
abstract class Person implements Hit{
}
public class Main {
public static void main(String[] args) {
//父类就是大，子类就是小【向上转型：父类的引用指向子类对象】
Person s1 = new man();
s1.say(); //如果Person类中没有say方法则不能调用
s1.talk(); //调用的是man类中的talk方法，而不是Person类中的talk方法，如果man类中没有talk方法，则调用Person类中的talk方法
Person s2 = new woman();
s2.say();
//【向下转型：将父类实例转为子类实例（强制转换）】
man w1 = (man)s1;
w1.say();
//man w2 = (man)s2; 不能这样转
}
}
/**
* 多态性：1.方法的重载与重写 2.对象的多态性
*/
abstract class Person{
String name;
abstract public void say();
public void talk(){
System.out.println("hi I'm a person.");
}
}
class man extends Person{
public void say(){
System.out.println("I'm a man.");
}
public void talk(){
System.out.println("hi I'm a man.");
}
}
class woman extends Person{
public void say(){
System.out.println("I'm a woman.");
}
}
/**
* Instanceof关键字：用于判断某一个对象是否为某个类的实例，返回布尔值
*/
public class Main {
public static void main(String[] args) {
Man m1 = new Man();
say(m1);
Woman m2 = new Woman();
say(m2);
}
public static void say(Person p){
p.say();
if(p instanceof Woman){
Woman w = (Woman)p;
w.getangry();
}
}
}
class Person{
public void say(){
System.out.println("I'm a person.");
}
}
class Man extends Person{
public void say(){
System.out.println("I'm a man.");
}
}
class Woman extends Person{
public void say(){
System.out.println("I'm a woman.");
}
public void getangry(){
System.out.println("I'm angrying...");
}
}
/**
* 父类设计法则
* 能过instanceof关键字，我们可以方便地检查对象类型，但如果一个父类的子类过多，这样的判断还是显得很繁琐
* 如何设计父类？
* 1.父类通常情况下都设计为抽象类或接口，其中优先考虑接口，如果接口不能满足才考虑抽象类
* 2.一个具体的类尽可能不去继承另一个具体类，这样的好处是无需检查对象是否为父类的对象
*/
/**
* 抽象类应用（灵鹫宫招聘）
* 模板方法模式：定义一个操作中的算法的骨架，而将一些可变部分的实现延迟到子类中。
* 模板方法模式使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定的步骤
*/
public class Main {
public static void main(String[] args) {
LinJiuGong lp = new Shemale("fish7");
lp.action();
}
}
abstract class LinJiuGong{
public void action(){ //招聘活动
if(competition()){
System.out.println("Congratulations, welcome to LinJiuGong !");
}else{
System.out.println("Sorry.....");
}
}
public abstract boolean competition(); //抽象方法
}
class Shemale extends LinJiuGong{
private String name;
Shemale(String name){
this.name = name;
}
public boolean competition(){ //实现比赛方法
System.out.println("Game start....I'm gonna win !");
Random r = new Random();
return r.nextBoolean();
}
}