构造、重写、重载、接口、【继承、抽象、多态、封装、】
构造
解释：就是不加修饰，方法名与类名相同的一个方法。在使用该方法的时候，只需要实例化类就可以了。
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修饰
继承
关键词：extends
特点：
子类可以拥有父类（除private修饰）的属性和方法。
子类可以随意重写和调用父类的方法。
Java是单继承，就是一个子类只能有一个父类（一个父类可以多个子类）
Java多重继承：比如A继承B，B继承C以此类推。
注意：object是所有类的父类。当一个类无继承时，则默认继承object
继承用的比较多，下面就随便举个例子：
package AA; public class 继承 { public static void main(String[] args) { } } class A{ } class B extends A{ } class C extends A{ } class D extends B{ }
此外还有一种：接口也属于继承的一种。
关键词：implements
package AA; public class 继承 { public static void main(String[] args) { } } interface A{ } class B implements A{ }
具体看上面
抽象
概念：说白了就是多个类同时调用同一个方法，但是重写的方法体不一样。
打个比方来说吧：
比如刚刚你告诉我你想要喝水，在这里我们把水最为一个抽象的概念，因为我不知道你是和橙汁还是白开水。然后我再把你和水的这个动作看成一个抽象方法。
假设，现在你在朋友家：你对我说你想要喝橙汁（橙汁看成一个类）。但是在你自己家：你对我说你想要和白开水（白开水看成一个类）
这样，我们就可以集合你喝的这个动作来实现你想要喝的是白开水还是橙汁。
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(); } }
多态
上面知道了重载（相同方法名，不同参数类型或参数个数）重写（继承父类，子类重写父类方法，例如：A de=new B();,A是父类，B是子类）。
多态：其实就是同个类型不同的实例对象（比如：动物类可以分小狗（小狗吃骨头汪汪叫）或者小猫（小喵吃鱼喵喵叫）。）
在了解之前先说说转型：
向上转型：
格式：父类 变量名=new 子类；
package AA; public class 转型 { public static void main(String[] args) { fulei de=new zilei();//向上转型 de.ff();//调用子类方法 de.qita();//调用父类方法 //de.qita1();//因为父类不含子类这个方法，所以不能调用 fulei de1=new zilei2();//向上转型 de1.ff();//调用子类方法 de1.qita();//调用父类方法 //de.qita1();//因为父类不含子类这个方法，所以不能调用 } } class fulei{ public void ff() { System.out.println("父类方法"); } public void qita() { System.out.println("父类其他方法"); } } class zilei extends fulei{ public void ff() { System.out.println("子类zilei重写父类方法"); } public void qita1() { System.out.println("子类zilei其它方法"); } } class zilei2 extends fulei{ public void ff() { System.out.println("子类zilei2重写父类方法"); } public void qita1() { System.out.println("子类zilei2其它方法"); } }
上面代码解释了：子类继承父类，重载父类的 “ff” 方法，最后最后实现对父类的引用对子类的实例化（调用方法）。但是（ //de.qita1();//因为父类不含子类这个方法，所以不能调用）
所以向上转型不能实例化父类没有的方法。因为当该子类被用成向上转型时，是不能使用父类不含有的方法的——缺点
改进：
上面代码我们这里我们想一下，如果有很多个子类，那我们岂不是要每个子类都要去new一次？
所以我们改进下
解释：重新创建一个方法，形参返回该父类的类型。最后使用该方法。
这样也充分的体现了Java的多态性，不仅提高代码效率，提简洁了代码——优点
关于向上转型还可以参考：
https://blog.csdn.net/guchenjun789/article/details/81055317
向上转型虽然使代码变得简洁，体现了JAVA的抽象编程思想，但是也出现了上面提到的子类无法调用其独有的方法，这要怎么解决呢？所以就有了与之对应的向下转型，弥补了向上转型所带来的缺陷。
向下转型：
格式：
父类 变量名=new 子类();
子类 变量名1=(子类)变量名;
关键词：
instanceof：判断该类是否为某类的父类（判断某对象是否是某类的实例）
package AA; public class 转型 { public static void main(String[] args) { show (new zilei()); } public static void show(fulei e) { if(e instanceof zilei) {//如果类（zilei）是fulei的子类，返回true zilei de=(zilei)e;//向下转型 de.qita1();//调用子类其他方法 de.ff();//调用子类方法 } } } class fulei{ public void ff() { System.out.println("父类方法"); } public void qita() { System.out.println("父类其他方法"); } } class zilei extends fulei{ public void ff() { System.out.println("子类zilei重写父类方法"); } public void qita1() { System.out.println("子类zilei其它方法"); } }
注意：向下转型其实就是为了弥补向上转型的缺陷的，一般一般情况下很少用向下转型。
关于向下转型还可以参考：
https://www.cnblogs.com/lifexy/p/10812841.html
其实将上面两个搞懂，多态基本都会了。下面在举个例子：
实现员工分发工资：如果是生产部门基本工资20万；检修部门基本工资5万；组织部门基本工资5块；现在小米、小明、小蜜分别是这个三个部分的。
package AA; public class 转型 { public static void main(String[] args) { ks de=new ks(); de.show (new 生产部门()); de.show (new 检修部门()); de.show (new 组织部门()); } } class gongzi { public void jibengz() {} } class 生产部门 extends gongzi{ public void jibengz() { System.out.println("小米基本工资200000"); } public void jixiao() { System.out.println("小米绩效工资20"); } } class 检修部门 extends gongzi{ public void jibengz() { System.out.println("小明基本工资50000"); } public void jixiao() { System.out.println("小明绩效工资10000"); } } class 组织部门 extends gongzi{ public void jibengz() { System.out.println("小蜜基本工资5"); } public void jixiao() { System.out.println("小蜜绩效工资209999"); } } class ks{ public void show (gongzi e) { e.jibengz(); if(e instanceof 生产部门) { 生产部门 de=(生产部门)e; de.jixiao(); } if(e instanceof 检修部门) { 检修部门 de=(检修部门)e; de.jixiao(); } if(e instanceof 组织部门) { 组织部门 de=(组织部门)e; de.jixiao(); } } }
关于多态还可以参考：
https://www.cnblogs.com/shuaifing/p/10762682.html
封装
将类的某些信息隐藏在类的内部，不允许外部程序直接访问，并通过该类提供的方法来实现对隐藏信息的操作和访问。
（简单的说就是隐藏对象的信息，给出固定的方法设置或者访问）。
特点：1.只能通过规定的方法访问数据；2.隐藏类的实例细节，方便修改和实现。
实现封装的方式:使用访问控制符
- private 在当前类中可访问
- default 在当前包内和访问
- protected 在当前类和它派生的类中可访问
- public 公众的访问权限，谁都能访问
可以参考：https://blog.csdn.net/someday_spark/article/details/80006215
package AA; public class 封装 { public static void main(String[] args) { lei de=new lei(); de.set_dee("你好世界！"); //System.out.println(de.dee);//错误，只能当前类或者继承类 System.out.println(de.get_dee()); } } class lei{ private int de; private String dee; //获取 public int get_de() { return de; } public String get_dee() { return dee; } //设置 public void set_de(int de) { this.de=de;//前面的de是私有的成员变量 } public void set_dee(String dee) { this.dee=dee;//前面的dee是私有的成员变量 } }
上面代码说明了：封装的意义，封装可以提高代码安全性。
看了还不懂？那我们在修改一下：假设我们有个游戏，防止用户上传不文明的文字。并且年龄限制必须大于12岁。最后在获取该值。
package AA; public class 封装 { public static void main(String[] args) { lei de=new lei(); try { de.set_dee("cao"); } catch (lei e) { System.out.println("对不起，你的输入的文字中含有不文明的字体"); } } } class lei extends Exception{ private int de=8; private String dee; //获取 public int get_de() throws lei{ if(de<12) throw new lei();//抛出异常，如果小于12，不允许 else return de;// } public String get_dee() { return dee; } //设置 public void set_de(int de){ this.de=de;//前面的de是私有的成员变量 } public void set_dee(String dee) throws lei{ if(dee=="cao")throw new lei();//抛出异常，判断是否含有不文明字体 else this.dee=dee;//前面的dee是私有的成员变量 } }
这是主函数，我们先测试脏话
结果：抛出异常
这是主函数，我们再测试年龄限制
此时的int值8，小于12.
浙公网安备 33010602011771号