构造重写重载接口抽象多态封装继承

Posted 2021-03-07 xg-ai-tt

构造

解释：就是不加修饰，方法名与类名相同的一个方法。在使用该方法的时候，只需要实例化类就可以了。

class cz{
     cz() {
        System.out.println("不含参数的");
    }
    
    public void 使用() {
        new cz();
        //使用不含参数的构造方法
    }
}

 

 

重写

package AA;

public class cscz {
      public static void main(String args[]){
          Animal a = new Animal(); // Animal 对象
          Animal b = new Dog(); // Dog 对象
     
          a.move();// 执行 Animal 类的方法
          b.move();//执行 Dog 类的方法
          System.out.println(b.de);//这里是输出的父类里面的de，重写不适用于属性
       //   b.bark();
       }
}
class Animal{
    int de=10;
       public void move(){
          System.out.println("动物可以移动");
       }
    }
     
    class Dog extends Animal{
    int de=90;
       public void move(){
          System.out.println("狗可以跑和走");
       }
       public void bark(){
          System.out.println("狗可以吠叫");
       }
    }
     

以上代码解释了：方法重写，利用父类的引用类型实现子类的方法。在实例化子类对象时（ Animal b = new Dog(); // Dog 对象）Animal 是引用类型，后面的Dog才是实例化的对象。

1，在子类里面的方法必须在父类里面也要存在（这样才叫重写嘛）。

2，在上面里面（Animal b = new Dog(); // Dog 对象）Dog类作为类对象来使用。前面的Animal类作为引用类型。
像这样称为：向上转型
这也是Java多态的一种（父类的引用指向子类的对象）。调用的方法就叫”虚方法“

 

重写不适用于属性

调用方法的时候，这个方法被称“虚方法”。

   Animal b = new Dog(); // Dog 对象

 

 我们要知道，重写也是多态的一种

 

public class Person {
    int id=101;
    public void eat(){
        System.out.println("人吃饭");
    }
}
class Man extends Person{
    int id=102;
    public void eat(){
        System.out.println("男人吃饭");
    } 
}
public class Test {
    public static void main(String[] args) {
          Person p=new Man();
          p.eat();
          System.out.println(p.id);//输出的是Person对象的id属性
    }
}

参考：
https://www.cnblogs.com/shuaifing/p/10762682.html

 

重载

说白了就是：在一个类里面，方法名相同，参数类型或者数量不同。
重载分为：普通方法重载、构造方法重载

我们要知道，重载也是多态的一种

普通的：

class cz{
    public void 普通的() {
        System.out.println("不含参数的");
    }
    public void 普通的(int de) {
        System.out.println("含一个int参数的");
    }
    public void 普通的(int de,int de1) {
        System.out.println("含两个int参数的");
    }
    
    public void 使用() {
        new cz().普通的(12);
        //使用含有一个参数的方法
    }
}

 

构造重载：

构造重载说白了就是把方法名改为类名，不加修饰词

class cz{
     cz() {
        System.out.println("不含参数的");
    }
     cz(int de) {
        System.out.println("含一个int参数的");
    }
     cz(int de,int de1) {
        System.out.println("含两个int参数的");
    }
    
    public void 使用() {
        new cz(12);
        //使用含有一个参数的构造方法
    }
}

 

接口

概念：当一个子类想要拥有多个父类的时候就是接口出场了（接口是父类用，相当于一个干爹）

 

格式：

创建：interface
例如：interface 接口{}

调用：implements 
例如：class de implements 接口{}

 

package AA;

public class 接口 {
public static void main(String[] args) {
    new 调用().ffa();
}
}


 interface  jk{
    void ffa();
}
 
 class 调用 implements jk{
     public void ffa() {
         System.out.println("实现接口方法");
     }
 }

 

注意事项：

接口里面的属性都是public，static，final，所以调用接口里面的方法必须要加public（值得接口里面方法），不然就会降低可视性（报错）

 

不使用方法*

对于有些时候我们调用接口只想要里面的变量不要方法。前面说了，既然调用那么就必须要是用里面的方法，
而这里面呢，不想使用的话，就必须在类前面声明此类为抽象类！

package AS;

 public abstract class de implements de11{
    public static void main(String[] args) {
        System.out.println("没有执行接口方法");
    }
 }
 
 interface de11{
     void fangfa();
 }

 

1，接口里面的方法只能是抽象方法
2，对于不想使用接口方法得类必须要加 abstract修饰

 

 

 

抽象

概念：说白了就是多个类同时调用同一个方法，但是重写的方法体不一样。

打个比方来说吧：
比如刚刚你告诉我你想要喝水，在这里我们把水最为一个抽象的概念，因为我不知道你是和橙汁还是白开水。然后我再把你和水的这个动作看成一个抽象方法。
假设，现在你在朋友家：你对我说你想要喝橙汁（橙汁看成一个类）。但是在你自己家：你对我说你想要和白开水（白开水看成一个类）
这样，我们就可以集合你喝的这个动作来实现你想要喝的是白开水还是橙汁。

package AA;

public class 抽象 {
public static void main(String[] args) {
    朋友家 de=new 朋友家();
    de.喝();
    自己家 de1=new 自己家();
    de1.喝();
}
}

abstract class 水{
    abstract public void 喝();
}

class 朋友家 extends 水{
    public void 喝() {
        System.out.println(朋友家.class.toString()+"你喝橙汁");
    }
}

class 自己家 extends 水{
    public void 喝() {
        System.out.println(自己家.class.toString()+"你喝白开水");
    }    
}

看完上面代码是不是很疑惑？为什么我不直接声明两个类，直接实现方法呢？这样抽象不是多此一举吗？

其实在上面代码中确实可以直接写方法。但是我们抽象就是为了能够为后面打基础，如果一个程序的代码量很高了。当我们实现抽象类的话，别人看到你的代码，他就会知道这个抽象类肯定有不少子类实现该方法。假设你没写抽象，只写了类但是却不知道在哪实现的方法，那个人肯定想骂你。

参考：https://blog.csdn.net/BD_fuhong/article/details/90600632

抽象类注意事项：

关键词：abstract(放最前面)

抽象类如果是共有的（public），那么就算不给他的方法加public，他也是隐含的。

1，不能调用，所以平时创建的他的什么子类别加抽象，只能被继承

2，有抽象方法必有抽象类

3,抽象类的子类中，必须将对象（变量或者其它）使用完，不然的话子类就是继承的抽象（前面必须加abstract）具体看程序

注意：抽象类必须有子类（否则，定义的抽象类将是无意义的）

 

 

abstract的加与不加区别

首先抽象类里面的抽象方法：

1，必须是要加abstract，因为那是抽象方法的标志,

2，也可以不加，但必须有方法体

科普下：抽象类里面不一定有抽象方法，但是，接口里面只能是抽象方法，而调用接口（就好像继承）也必须使用抽象方法，否则出错

 

接口与抽象的区别

首先说说接口：接口：当一个父类拥有一个子类是，但这个子类又必须有另外个父类，接口就可以实现
接口类里面只能是抽象方法（就是没有方法体）

1，有一个专属的类，关键词是：interface
列如：public interface  类名{}
2，接口是被调用的，调用关键词：implement
列如：public class 类名 implement 接口类名{}

 

再来说说抽象：它含有抽象类和抽象方法，抽象类不一定含有抽象方法
声明抽象类关键词：abstract calss 抽象类{}
**抽象类里面，可以有抽象方法：abstract double getArea();--必须加abstract，并且继承他的子类也必须实现该方法
也可以是普通的方法：public void de(){} --不需要加abstract，并且其他子类是选择性实现该方法

**继承的子类里面，

①：实现抽象方法，直接写出该父类方法名就可以，但是要加方法体
②：不实现抽象方法，必须在该子类前边加抽象关键词：abstract

 

接下来，来点进阶的：

package AA;
abstract class Shape{
abstract double getArea();    
}
 class Rectangle extends Shape{
     double a,b;
     Rectangle(int a,int b){//构造函数
         this.a=a;
         this.b=b;
     }
     double getArea(){//将值拿来用
         System.out.println(a*b);
        return a*b;
    }
}
 class Circle extends Shape{
     double r,t;
     
     double getArea(){
            return r*t;
        }
}
public class xin {

    public static void main(String[] args) {
        Rectangle de=new Rectangle(2,3);
        de.getArea();
        Circle de1=new Circle();
        de1.getArea();
    }
}

 

多态

 上面知道了重载（相同方法名，不同参数类型或个数）重写（继承父类，子类重写父类方法）。

 

参考：
https://www.cnblogs.com/shuaifing/p/10762682.html