**同样的**对于**成员变量**如果在前面加入final这个修饰符，就代表最终态，就是一个常量了，不可在局部变量中在进行赋值
public class demo{ public final int age=10; public void zi(){ age=20;//这里赋值也不会再起作用，还会报错 } }
还有final修饰类，就代表是最终类，就不能被使用:
public final class Fu { public void show(){ System.out.println("父中方法被调用"); } }
上面有final修饰类，那么子类就不能继承
**总结:**
final修饰的特点
* **修饰方法**：修饰方法:表明该方法是最终方法，不能被重写
* **修饰变量**：表明该变量是常量，不能再次被赋值
* **修饰类**：表明该类是最终类，不能被继承
**final** **修饰局部变量**：
* 修饰基本类型变量
被它修饰后，局部变量不可再用
* 修饰引用类型
对于修饰类型，修饰的是地址，而里面的内容可以改变
public class Student{ public int age=10; }
那么它输出的就会是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, 清华大学
**访问特点:**
## 3. 多态
### 3.1 多态概述
\*\*概述：\*\*同一对象，在不同时刻表现出来的不同形态
* 有继承关系：
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 多态的好处与弊端
测试类
狗类：
猫类：
操作类：
测试结果：
### 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 抽象类特点
**实例化**
//猫类 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;//可以是常量
private String name;//也可以是变量
}
**一、Python所有方向的学习路线**
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。
**二、Python必备开发工具**
工具都帮大家整理好了，安装就可直接上手！
**三、最新Python学习笔记**
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。
**四、Python视频合集**
观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
**五、实战案例**
纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
**六、面试宝典**
###### **简历模板**
**了解详情：https://docs.qq.com/doc/DSnl3ZGlhT1RDaVhV**
