[AppleScript] 纯文本查看 复制代码
class Demo_employee {
public static void main(String[] args) {
coder c = new coder("冬冬","110",15000);
c.work();
System.out.println("--------------------");
manager m = new manager("苍老师","120",15000,20000);
m.work();
}
}
abstract class employee{ //因为本类中抽象方法那么，类一定要是抽象的，但是抽象的类，不一定要有抽象方法，
private String name; //有抽象方法，类一定是抽象的
private String id;
private double salary;
public employee(){}
public employee(String name,String id,double salary){
this.name = name;
this.id = id;
this.salary = salary;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setId(String id){
this.id = id;
}
public String getId(){
return id;
}
public void setSaraly(double salary){
this.salary = salary;
}
public double getSalary(){
return salary;
}
public abstract void work();//我们之知道他们两个都有工作的这个行为，但是我们不知道他们具体是怎么工作的，所以定义为抽象方法
}
class coder extends employee{
public coder(){}
public coder(String name,String id,double salary){
super(name,id,salary);
}
public void work1(){
System.out.println("我的工作是写代码");
}
public void work(){
System.out.println("我的姓名是："+getName()+'\n'+"我的工号是："+getId()+'\n'+"我的工资是："+getSalary());
work1();//本来中的方法可以直接调用
}
}
class manager extends employee{
private int jiangjin; //这是子类中特有的属性
public manager(){}
public manager(String name,String id,double salary,int jiangjin){//对象要传递四个参数过来这里就必须有四个参数接收，保持参数长度相同
super(name,id,salary);//父类中只有三个参数，所以这里也只能传递三个参数、、、、、注意
this.jiangjin = jiangjin;//this调用本来中属性，也就是，对象传递过来四个参数，super将三个参数传递给父类，this将一个给本类
}
public void work1(){
System.out.println("我的工作是服务程序员");
}
public void work(){ //因为父类中有抽象方法，那么子类就一定要对这个抽象方法进行重写，这是强制的
System.out.println("我的姓名是："+getName()+'\n'+"我的工号是："+getId()+'\n'+"我的工资是："+getSalary()+'\n'
+"我的奖金是："+jiangjin);
work1();
}
}[AppleScript] 纯文本查看 复制代码
class Demo_Interface_test {
public static void main(String[] args) {
//下面这两段，是正常写法，代码的复用性太差了；简化代码，请看第37行到47行
//第一个Cat类使用多态
/*Anilam a = new Cat("萌萌","粉色",4);//使用有参构造创建对象，并且是父类引用指向子类对象（多态的一个条件）
System.out.println("我的名字是："+a.getName()+'\n'+"我是:"+a.getColor()+'\n'+"我今年："+a.getAge()+"岁");
a.eat();
a.sleep();
Cat c = (Cat)a;//向下转换，因为在多态中，子类的特有成员方法不能被调用，需要向下转换才可以，调用
c.mengmengda();//向下转换后，可以调用
System.out.println("-------------------------------------");
//第二个Cat类使用多态
Anilam d = new Dog("蛋蛋","黑色",2);//父类引用指向子类对象（多态的条件）
System.out.println("我的名字是："+d.getName()+'\n'+"我是:"+d.getColor()+'\n'+"我今年："+d.getAge()+"岁");
d.eat();
d.sleep();
Dog y = (Dog)d;
y.yaoren();*/
System.out.println("-------------------------------------");
//这里使用了接口，体现了接口的扩展性，经过培训的狗狗，虽然有他特有的技能，但是，他还是具备所有狗类具有的行为属性
Inter i = new yDog();//接口引用指向子类对象，也就是父类引用指向子类，这里可以把这个父类，理解成干爹
i.yy();//调用子类方法
System.out.println("-------------------------------------");
//这块其实和上面的是重复的
Dog m = new yDog("99","888",23);
System.out.println("我的名字是："+m.getName()+'\n'+"我是:"+m.getColor()+'\n'+"我今年："+m.getAge()+"岁");
m.eat();
m.sleep();
yDog y1 = (yDog)m;
m.yaoren();
y1.chishi();
//使用多态的好处，可以当成参数传递，节省代码量
mothod(new Cat("萌萌","粉色",4));
mothod(new Dog("蛋蛋","黑色",2));
}
//使用多态，可以当做参数传递，那就可以抽取方法，请看下面是抽取到的方法
public static void mothod(Anilam a){
System.out.println("我的名字是："+a.getName()+'\n'+"我是:"+a.getColor()+'\n'+"我今年："+a.getAge()+"岁");
a.eat();
a.sleep();
}
}
/*
A:案例演示
* 动物类：姓名，年龄，吃饭，睡觉。
* 猫和狗
* 动物培训接口：跳高
*/
abstract class Anilam{ //定义抽象类，动物是一个群体里面都包括什么我们不知道，所以定义为抽象类
private String name; //定义了一个私有的成员变量，私有的成员变量不能被子类访问
private String color;
private int age;
public Anilam(){}//空参构造，可以使用空参构造，子类可以访问本类中私有成员变量
public Anilam(String name,String color,int age){//有参参构造，可以使用从参构造，子类可以访问本类中私有成员变量
this.name = name;
this.color = color;
this.age = age;
}
public void setName(String name){ //设置姓名
this.name = name;
}
public String getName(){ //获取姓名
return name;
}
public void setColor(String color){ //设置年龄
this.color = color;
}
public String getColor(){ //获取年龄
return color;
}
public void setAge(int age){ //设置年龄
this.age = age;
}
public int getAge(){ //获取年龄
return age;
}
public abstract void eat();//定义抽象方法、、抽象对象中既可以有抽象方法，也可以有非抽象方法，
public abstract void sleep();//但是类里面如果有抽象方法，那么他就一定的是抽象类
}
class Cat extends Anilam{ //子类继承父类，这里是Cat继承Anilam
public Cat(){} //空参构造，用来给父类和本类初始化
public Cat(String name,String color,int age){
super(name,color,age);
}
public void eat(){
System.out.println("我吃鱼");
}
public void sleep(){
System.out.println("我喜欢躺着睡");
}
public void mengmengda(){ //这是子类中特有的方法，在多态中没有办法直接调用，but，可以使用向下转型来调用，请看9-10行
System.out.println("我萌死人不偿命");
}
}
class Dog extends Anilam{ //子类继承父类，BUT，父类是一个抽象类，所以我们要对他的抽象方法进行重新，这是强制的
public Dog(){}
public Dog(String name,String color,int age){
super(name,color,age);
}
public void eat(){ //这里是对父类对象中的抽象方法进行强制重写，这是规则，必须遵守
System.out.println("我喜欢吃肉");
}
public void sleep(){ //同上，这也是强制重写父类的抽象方法
System.out.println("我喜欢趴着睡");
}
public void yaoren(){
System.out.println("我专咬坏蛋");//这是子类中特有的方法，在多态中没有办法直接调用，but，可以使用向下转型来调用，请看18-19行
}
}
interface Inter{ //定义了一个接口，关于接口，接口里面必须全部都是抽象方法，他其实是对子类的一种扩展，可以是多继承的
public void yy();//接口中的抽象方法
}
class yDog extends Dog implements Inter{ //这里是yDog先继承了他的父类Dog,然后还实现了（这里可以理解为利用）Inter
//所以，这里是可以多实现的，因为我能利用这个，就能利用那个
public yDog(){}
public yDog(String name,String color,int age){
super(name,color,age);
}
public void eat(){
System.out.println("我喜欢吃肉");
}
public void sleep(){
System.out.println("我喜欢趴着睡");
}
public void yy(){
System.out.println("经过培训的狗狗可以游泳");//接口的子类，必须对接口的抽象方法进行强制重写，不重写都不行
}
public void chishi(){
System.out.println("有时会吃屎");
}
}
/*接口的子类，如果还继承了其他抽象父类，那么用法和多态是一样的，子类特有方法不能被直接调用，不过可以使用向下转型来调用*/