javase基础三大特征之一“多态”_classfu public final void show

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

那么它输出的就会是100，而不是10  
 **总结：**


* 变量是基本类型: final修饰指的是基本类型的数据值不能发生改变
* 变量是引用类型: final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的


#### static关键字


**static 是静态的意思，可以修饰成员方法，成员变量  
 对于一个事物，别的事物都需要它来共享，这样建议使用static来进行修饰**  
 例如，很多个学生来自同一个大学，但年龄，性别不同，这里，赋值时，因为多个同学来自同一个大学，那么大学就是一个静态的，共享的，赋值时如果给每个学生大学都赋值同一个大学，那么会显得臃肿，用static修饰大学就是不错的选择


**主函数部分：**

public class main {
public static void main(String[] args) {
stu.university=“清华大学”;//直接给大学赋值，建议使用这种方式来进行给静态赋值
stu s1=new stu();
s1.name=“张三”;
s1.age=18;
s1.show();
stu s2=new stu();
s2.name=“李四”;
s2.age=19;
s2.show();
}

**学生类部分**

public class stu{
public String name;
public int age;
public static String university;//加上静态修饰符，可以共享
public void show(){
System.out.println(name+", “+age+”, "+university);
}
}

那么输出结果就是：

张三, 18, 清华大学
李四, 19, 清华大学

**访问特点:**  
 ![特点](https://img-blog.csdnimg.cn/6d966a4f0ce3484c86f25698b1e4c71e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5rC05YWs5a2Q,size_17,color_FFFFFF,t_70,g_se,x_16)


## 3. 多态


### 3.1 多态概述


\*\*概述：\*\*同一对象，在不同时刻表现出来的不同形态  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/537cdcff64c84700b107f09d7b709f6f.png)


* 有继承关系：

public class Cat extends Animal{//继承关系
@Override
public void eat(){//方法重写
System.out.println(“猫爱吃鱼”);
}
}

* 方法重写：

public class Animal {

public void eat(){
    System.out.println("动物吃肉");
}

}

* 父类引用指向子类对象：

public class AnimalDemo {
public static void main(String[] args) {
Animal animal=new Cat();//多态，父类引用指向子类对象，这里也就是下面说的向上转型
}
}

### 3.2 多态中成员访问特点


成员变量：编译看左边，执行看左边  
 成员方法：编译看左边，执行看右边

//子类
public class Cat extends Animal{//继承关系
public int age=40;
@Override
public void eat(){//方法重写
System.out.println(“猫爱吃鱼”);
}
public void playGame(){
System.out.println(“猫爱玩”);//非重写
}
}

//父类
public class Animal {
public int age=30;
public void eat(){
System.out.println(“动物吃肉”);
}
}

//测试类
public class AnimalDemo {
public static void main(String[] args) {
Animal animal=new Cat();//多态
System.out.println(animal.age);
//运行结果是左边Animal,则age=30,
//如果Animal没有age，则会报错
//----------------------------------
animal.eat();//方法重写执行看右面
//输出的是Cat里面的方法
//----------------------------------
animal.playGame();//这时就会报错
//执行左面Animal里面没有这个方法
}
}

`为什么成员变量和成员方法的访问不一样呢?`  
 因为成员方法有重写,而成员变量没有


### 3.3 多态的好处与弊端


![在这里插入图片描述](https://img-blog.csdnimg.cn/05fb0d787c0a4451b12c52caa63ffd9c.png)


测试类  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/01ade4bbdd674cafb802f31ffdc14dde.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5rC05YWs5a2Q,size_20,color_FFFFFF,t_70,g_se,x_16)  
 狗类：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/7c4b51df614246b9b6b149cb954d89d4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5rC05YWs5a2Q,size_20,color_FFFFFF,t_70,g_se,x_16)  
 猫类：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/630e9ef2bf114cee88f3aa47eabaf51e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5rC05YWs5a2Q,size_20,color_FFFFFF,t_70,g_se,x_16)  
 操作类：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/c7f8cf4332d648469fbead84885eb8cf.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5rC05YWs5a2Q,size_20,color_FFFFFF,t_70,g_se,x_16)  
 测试结果：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/b3293bebacf74e4c88240c5f39f7e031.png)


### 3.4 多态中的转型


* **向上转型** 从子到父，父类引用指向子类对象
* **向下转型** 从父到子，父类引用转为子类对象  
 向上转型，上面的有实例，这里不在叙述，  
 关于向下转型，也就是在子类中，如果不用父类的方法时，想要用自己的方法时，还不能出现报错，这里就要用向下转型，从而实现  
 例如：  
 在猫类中有方法eat，而猫类继承父类，父类也有eat方法，这就实现了猫类方法重写，而在猫类中还有方法Game(),而父类没有此方法，那么使用时就会报错，如果不想报错，就要实施类似强转

//子类

public class Cat extends Animal{//继承关系
@Override
public void eat(){//方法重写
System.out.println(“猫爱吃鱼”);
}
public void playGame(){//这里方法没被重写，按照编译看左面，看父类中没有就会报错，
//下面向下转型就可以实现这个问题
System.out.println(“猫爱玩”);//非重写
}
}

//父类
public class Animal {
public void eat(){
System.out.println(“动物吃肉”);
}
}

//测试类
public class AnimalDemo {
public static void main(String[] args) {
Animal animal=new Cat();//多态，向上转型，父类引用指向子类对象
animal.eat();//这里因为有重写方法，所以执行看右面，看cat中的eat,所以会输出猫爱吃鱼
/*这里我如果还想调用cat中的playGame()方法，显然会报错，那么、怎末不让它报错呢，就要用到向下转型
*/
Cat c= (Cat)animal;//后面的(Cat)animal是父类引用作为子类对象，转为Cat,
//那么就可以实现调用子类独有的方法了
c.playGame();
}

}

## 4.抽象类


### 4.1 抽象类概述


**概述**  
 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类  
 用`abstract`表示抽象

public abstract class Animal {//抽象类
public abstract void eat();//定义抽象方法
}

### 4.2 抽象类特点


![在这里插入图片描述](https://img-blog.csdnimg.cn/87d89f1a4720443bba74f0f183879ba4.png)


**实例化**

//猫类
public class Cat extends Animal{//继承关系
public void eat() {//重写父类方法，有抽象类的方法
System.out.println(“猫吃鱼”);
}
}

//Animal类
public abstract class Animal {//抽象类
public abstract void eat();//定义抽象方法
public void sleep(){//抽象类中一定有抽象的方法，但也可有不抽象的方法
System.out.println(“睡觉”);
}
}

//狗类
public abstract class dog extends Animal {
//这里如果不想重写所有方法，就需要在加abstract
}

测试类
public class AnimalDemo {
public static void main(String[] args) {
Animal c = new Cat(); //采用多态方式
c.eat();//调用eat方法，遵循编译看左面，执行看右面
c.sleep();//尽管猫类中没有，但是会继承父类中的
}
}

运行结果

猫吃鱼
睡觉

### 4.3 抽象类的成员特点


* 可以提供构造方法，但是不能实例化
* 构造方法作用是子类访问父类数据的初始化
* 成员变量可以是变量，也可以是常量
* 成员方法 可以有抽象方法：限定子类完成某些动作；也有非抽象方法：提高代码复用性

public abstract class xxx(){
public xxx(){}//无参构造方法
public xxx(String name){//有参构造方法
this.name=name;
}
}

public abstract class xxx(){

private final int age=10;//可以是常量

（1）Python所有方向的学习路线（新版）

这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

最近我才对这些路线做了一下新的更新，知识体系更全面了。

（2）Python学习视频

包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

（3）100多个练手项目

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！