标签：多个 其他 this 程序 sdn -- 实例 引用类型 public
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(); }
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）具体看程序
注意：抽象类必须有子类（否则，定义的抽象类将是无意义的）
首先抽象类里面的抽象方法：
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
标签：多个 其他 this 程序 sdn -- 实例 引用类型 public
原文地址：https://www.cnblogs.com/xg-ai-tt/p/12360509.html
