诸葛孔明有言：用兵之道,攻心为上,攻城为下;心战为上,兵战为下
这里写目录标题
1.封装
（1）封装的概念💕
概念：将对象的某些属性和方法实现细节等等隐藏，只能通过代码编写者提供的接口来访问，典型代表get，set方法。
（2）封装的好处💕
1.提高了代码的安全性，因为外部不能轻易的访问or修改对象内部等等属性。
2.由于代码内部细节被隐藏，别人使用时只提供接口，可以保护代码编写者的专利
3.提高代码复用性，将经常使用的代码块封装，使用时直接调用即可。
（3）封装的演示💕
准备工作：❤️
所利用权限修饰符：private
在这里提供全部权限修饰符的权限范围💖
权限大小：public > protected > 默认(就是不写) > private
将属性用private修饰，然后对外提供get和set方法访问该属性，使其不能再通过对象.属性名的方式访问。就像这样：
class Pig{
private String name;
private int age;
Pig(){}//无参构造方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void print(){//输出小猪信息
System.out.println(name);
System.out.println(age);
}
}
2.继承
(1)继承的概念
🎶将多个类的共性抽象出一个父类，实现代码复用。
（2）继承的优缺点
🎶优点：
1.实现了代码复用
2.提高了代码的可维护性（修改父类即可）
🎶缺点
1.不太满足低耦合的特性，因为继承会使得代码的耦合性增强，不利于代码的修改【可改进性】，一次修改，到处报错。
（3）继承的特点🐲
我们说继承的优点有代码复用，那究竟体现在哪呢？
1.通过继承，子类可以访问父类所有非private修饰的方法和属性
其次：
2.java不可多继承。即B extends A1,A2是不被允许的。
（4）继承演示😶🌫️
演示事项：
😶🌫️1.子类进行实例化操作时，会调用父类的构造方法【演示1】
😊2.子类属性和父类属性同名时【演示2】
🙊3.子类方法和父类方法同名时【演示3】
👿4.究极问题【会这个真的很🐂🐃🐄】
演示1
public class Demo1 {
public static void main(String[] args) {
Zi zi=new Zi();
}
}
class Fu {
Fu(){
System.out.println("我是父类无参构造方法");//
}
}
class Zi extends Fu{
Zi(){
//其实这里编译器默认有一个无参构造方法super();
System.out.println("我是子类无参构造方法");//
}
}
演示2
public class Demo1 {
public static void main(String[] args) {
Zi zi=new Zi();
}
}
class Fu {
protected int num=10;
Fu(){}
}
class Zi extends Fu{
public int num=20;
Zi(){
System.out.println(num);//优先调用子
System.out.println(super.num);//添加super关键字会调用父
}
}
演示3
方法和演示2
一致，就偷个懒啦。
究极问题
public class Demo1 {
public static void main(String[] args) {
Zi zi=new Zi();
}
}
class Fu {
protected int num=10;
Fu(){
System.out.println("我是父类无参构造方法");
}
{
System.out.println("我是父类实例代码块");
}
static {
System.out.println("我是父类静态代码块");
}
}
class Zi extends Fu{
public int num=20;
Zi(){
System.out.println("我是子类无参构造方法");
}
{
System.out.println("我是子类实例代码块");
}
static {
System.out.println("我是子类静态代码块");
}
}
给大家一些思考时间：sleep（30000）；
🐣ok，公布答案：
相信大家肯定都说对了！❤️💖💕
注意事项：😶🌫️
1.this和super关键字不能同时存在
正所谓一山容不得二虎（bushi），是因为调用其他构造方法只能写在当前构造方法的第一行，super和this不可能都在第一行对不对。
2.this，super只可在非静态方法调用非静态成员。
依赖对象
3.被final修饰的类无法被继承，称作密封类
4.相较于继承，其实组合更加好【即一个类的实例作为另一个类的字段（属性）】，可以降低耦合度。
3.多态
1.多态的概念🐠
同一种行为，在不同对象的不同表现形式。例如都是吃这个动作，😽猫吃猫粮，而🐶狗吃狗粮。
2.多态的要求
🐊存在向上转型
即父类引用指向子类对象Fu demo=new Zi();
特点：1.只可调用父类的方法，无法调用子类独有的方法（若调用，会发生编译错误）。
因为编译时，它看的是父类有没有这个方法，在运行时，如果子类重写该方法，他就会调用子类的，这也叫动态绑定🐣🐻
🦖方法重写
在这之前先回顾一下方法重载的概念：在同一类中，方法名称相同，方法的参数列表【即参数的数量，参数的类型，参数的顺序】不同就叫做方法重载【ps：与返回值无关】
那么方法重写：子类继承父类时，对父类已有的方法，在不改变方法的名称，参数列表和返回值【除特殊情况外】的前提下，对父类方法的方法内容进行改写就叫做方法重写。
🐠这里的特殊情况就是方法重写的返回值可以不相同，我们直接上代码：
class Fu {
protected Fu init(){//也就是返回值也满足父子类关系！！！
System.out.println("我是父类的init方法");
return new Fu();
}
}
class Zi extends Fu{
public Zi init(){
System.out.println("我是子类的init方法");
return new Zi();
}
}
注意事项：
1.首先static修饰的方法，不要重写，因为重写也没有效果【大家可以尝试一下】。然后final，private修饰的方法不能重写。
2.方法重写时，子类的权限修饰符不能低于父类方法的权限修饰符。
例如不能父类方法用的是public，而子类是private。🐌
3。方法重写时子类抛出的异常不能超过父类相应方法抛出的异常，可能现在说异常大家不太明白，这个在往后异常类的学习中大家就会了解了，下面是该条的演示。
🐉父类引用调用重写的方法
这个需要直接上代码：
public class Demo1 {
public static void main(String[] args) {
Fu demo=new Zi();
demo.init();//这里的demo就是父类引用🐣
}
}
class Fu {
protected void init(){
System.out.println("我是父类的init方法");
}
}
class Zi extends Fu{
public void init(){
System.out.println("我是子类的init方法");
}
}
3.额外宝藏🦄
1.什么是向下转型？🙉
并非Zi demo=new Fu();
而是：
Fu demo=new Zi（）；//该行是转型的前提：即已引用该实例
Zi test=（Zi）demo//就是强制类型转换
通过这种方式就可以调用子类独有的方法了！！！
不过不建议使用这种写法哦~
2.方法重写的原则？🙊
©对修改关闭，对拓展开放
即当前方法不能满足某种需求时，不是去修改代码，而是通过多态这个概念去拓展这个方法在这种需求下的功能。
3.静态绑定是什么？🙈
即编译期间就确定了调用的方法是哪个。
4.小tip：🐻
创建对象会调用构造方法，调用构造方法不一定就是创建本类对象
写在最后
相信看到这里，你已经对面向对象的三大特性有了更深刻的理解，感谢阅读哦~~😽😽😽😽😽😽😽
如果是点赞的话，也不是不可以哦💕💖💖💖💖
扫一扫
1874
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
