今天的知识是我在这里的基础班学习的最后一天的内容了，所以请你一定要坚持把今天的学完，再决定要不要继续，加油吧！
今天主要是多态、内部类
多态
多态是继封装、继承之后，面向对象的第三大特性。
定义
多态： 是指同一行为，具有多个不同表现形式。
前提【重点】
1. 继承或者实现【二选一】
2. 方法的重写【意义体现：不重写，无意义】
3. 父类引用指向子类对象【格式体现】
多态体现的格式：
父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。
代码如下：
多态的好处
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。
代码如下
定义测试类：
public class Test {public static void main(String[] args) {// 多态形式，创建对象Cat c = new Cat();Dog d = new Dog();// 调用showCatEatshowCatEat(c);// 调用showDogEatshowDogEat(d);/*以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代而执行效果一致*/showAnimalEat(c);showAnimalEat(d);}public static void showCatEat (Cat c){c.eat();}public static void showDogEat (Dog d){d.eat();}public static void showAnimalEat (Animal a){a.eat();}}
由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。
当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。
所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。
引用类型转换
多态的转型分为向上转型与向下转型两种：
为什么要转型
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
转型演示，代码如下：
转型的异常
转型的过程中，一不小心就会遇到这样的问题，请看如下代码：
这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
interface作为方法参数
当接口作为方法的参数时,需要传递什么呢？对，其实都是它的子类对象。 ArrayList 类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所以，当我们看见List 接口作为参数或者返回值类型时，当然可以将ArrayList 的对象进行传递或返回。
这是今天的第二大块知识
内部类
什么是内部类
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
成员内部类
成员内部类 ：定义在类中方法外的类。
在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类Car 中包含发动机类Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。
访问特点
内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。
创建内部类对象格式：
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。
比如，Person$Heart.class
匿名内部类
匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的 父类或者父接口的 匿名的 子类对象。
开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，
1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法
我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。
前提
匿名内部类必须继承一个父类或者实现一个父接口。
使用方式
以接口为例，匿名内部类的使用，代码如下：
创建匿名内部类，并调用：
通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：
到此基础班的知识学完了，从明天开始更新后续的知识，学如逆水行舟不进则退，既然学了，就坚持到底学习完。

文章目录
1. 方法
1.1 方法的特性
1.2 私有属性
1.3 property装饰器
1.4 方法的重写
1.5 特殊方法和运算符重载
1.6 特殊属性
2. 面向对象的三大特性
2.1 继承
2.2 多态

1. 方法
python中，方法的参数没有类型，参数数量可变，python中没有方法的重载。

如果定义了多个重名的方法，只有最后一个有效。
1.1 方法的特性
方法的动态性：python是动态语言，可以动态地为类增添新方法或动态地修改类的已有方法。
class Person:
    def work(self):
        print('work hard')
def play_game(a):
    print('{0}在玩游戏'.format(a))
Person.play=play_game#添加新方法
p=Person()
p.work()

p.play()

1.2 私有属性
python对于类的成员没有严格的访问控制限制：

1.两个下划线开头的属性是私有的，其他为公共的

2.类内部可以访问私有属性/方法

3.类外部不能直接访问私有属性/方法

4.类外部可以通过 ‘_类名__私有属性/方法名’访问私有属性/方法
class Employee:
    def __init__(self,name,age):
        self.name=name
        self.__age=age#私有属性
    def __work(self):#私有方法
        print('work hard')
e=Employee('JOJO',18)
print(e.name)
print(e._Employee__age)#访问私有属性
e._Employee__work()#调用私有方法

1.3 property装饰器
@property装饰器可以将一个方法的调用方式变为属性调用
lass Employee:
    def __init__(self,name,salary):
        self.__name=name
        self.__salary=salary
    @property
    def salary(self):#变为属性调用
        return self.__salary

    @salary.setter
    def salary(self,salary):
        if 1000<salary<50000:
            self.__salary=salary
        else:
            print('wrong')
emp1=Employee('jojo',30000)
print(emp1.salary)
emp1.salary=20000#修改属性
print(emp1.salary)

1.4 方法的重写
子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为重写。
class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say_age(self):
        print('age')
class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)
        self.score=score
    def say_age(self):#重写该方法
        print('reage')
s=Student('jojo',18,100)
s.say_age()

1.5 特殊方法和运算符重载
python中的运算符实际上是通过调用对象的特殊方法实现的，每个运算符都对应了相应的方法，重写该方法可以重载运算符。
class Shuzi:
    def __init__(self,shu):
        self.shu=shu
    def __add__(self, other):#重新定义运算符+的对应方法
        if isinstance(other,Shuzi):
            return "{0}--{1}".format(self.shu,other.shu)
        else:
            return "wrong"
p1=Shuzi(10)
p2=Shuzi(20)
x=p1+p2
print(x)

1.6 特殊属性
python对象中包含了很多双下划线开始和结束的属性，是特殊属性，有特殊用法，常见的特殊属性有：

obj.__dict __ ：对象的属性字典

obj.__class __：对象所属的类

class.__bases __类的父类元组（多继承）

class.__base __：类的父类

class.__mro __：类层次结构

class.__subclasses __()：子类列表
2. 面向对象的三大特性
python是面向对象的语言，也支持面向对象的三大特性：继承，封装，多态。

封装：隐藏对象的属性和实现细节，只对外提供必要的方法。通过私有属性，私有方法的方式，实现封装
2.1 继承
继承可以让子类具有父类的特性，提高了代码的重用性。

语法格式：支持多重继承，一个子类可以继承多个父类。

class 子类类名（父类1[,父类2,…]）

类体

如果类定义中没有指定父类，则默认父类是object类。object是所有类的父类，因此所有的类都有object类的属性和方法。

定义子类时，必须在其构造函数中调用父类的构造函数。

父类名.__ init__(self,参数列表)

子类可以继承私有属性，但不能直接使用。
class Person:
    def __init__(self,name,age):
        self.name=name
        self.__age=age#私有属性
    def say_age(self):
        print('age')
class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)#必须显式地调用父类的初始化方法，不然解释器不会调用
        self.score=score
s= Student('JOJO',18,100)
s.say_age()
print(s.name)
print(s._Person__age)#私有属性特殊调用

多重继承：支持多重继承，但是这样会被“类的整体层次”搞的很复杂，尽量避免使用。
class A:
    def aa(self):
        print('aa')
class B:
    def bb(self):
        print('bb')
class C(A,B):#AB同时为C的父类
    def cc(self):
        print('cc')
c=C()
c.aa()
c.bb()
c.cc()

mro(): method resolution order 方法解析顺序，可获得类的层次结构

super():代表父类的定义，不是父类对象。
class A:
    def say(self):
        print('A',self)
class B(A):
    def say(self):
        super().say()#代表父类的定义
        print('B',self)
B().say()

组合：has-a关系，也能实现一个类用于另一个类的方法和属性
class Phone:
    def __init__(self,cpu,screen):
        self.cpu=cpu
        self.screen=screen

class CPU:
    def caculate(self):
        print("cpu对象：",self)

class Scrren:
    def show(self):
        print('scrren对象',self)

m=Phone(CPU(),Scrren())#组合关系
m.cpu.caculate()#方法调用
m.screen.show()

2.2 多态
多态：同一个方法调用由于对象不同可能会产生不同的行为

1.多态是方法的多态，属性没有多态

2.多态的存在有两个必要条件：继承，方法重写
lass Man:
    def eat(self):
        print('eat')
class Chinese(Man):
    def eat(self):
        print('eat with chopsticks')
class English(Man):
    def eat(self):
        print('eat with fork')
def manEat(m):
    if isinstance(m,Man):
        m.eat()
    else:
        print('none')
manEat(Chinese())
manEat(English())#同一个方法产生不同行为

今天的知识是我在这里的基础班学习的最后一天的内容了，所以请你一定要坚持把今天的学完，再决定要不要继续，加油吧！
今天主要是多态、内部类
多态
多态是继封装、继承之后，面向对象的第三大特性。
定义
多态： 是指同一行为，具有多个不同表现形式。
前提【重点】
1. 继承或者实现【二选一】
2. 方法的重写【意义体现：不重写，无意义】
3. 父类引用指向子类对象【格式体现】
多态体现的格式：
父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。
代码如下：
多态的好处
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。
代码如下
定义测试类：
public class Test {public static void main(String[] args) {// 多态形式，创建对象Cat c = new Cat();Dog d = new Dog();// 调用showCatEatshowCatEat(c);// 调用showDogEatshowDogEat(d);/*以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代而执行效果一致*/showAnimalEat(c);showAnimalEat(d);}public static void showCatEat (Cat c){c.eat();}public static void showDogEat (Dog d){d.eat();}public static void showAnimalEat (Animal a){a.eat();}}
由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。
当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。
所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。
引用类型转换
多态的转型分为向上转型与向下转型两种：
为什么要转型
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
转型演示，代码如下：
转型的异常
转型的过程中，一不小心就会遇到这样的问题，请看如下代码：
这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
interface作为方法参数
当接口作为方法的参数时,需要传递什么呢？对，其实都是它的子类对象。 ArrayList 类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所以，当我们看见List 接口作为参数或者返回值类型时，当然可以将ArrayList 的对象进行传递或返回。
这是今天的第二大块知识
内部类
什么是内部类
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
成员内部类
成员内部类 ：定义在类中方法外的类。
在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类Car 中包含发动机类Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。
访问特点
内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。
创建内部类对象格式：
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。
比如，Person$Heart.class
匿名内部类
匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的 父类或者父接口的 匿名的 子类对象。
开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，
1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法
我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。
前提
匿名内部类必须继承一个父类或者实现一个父接口。
使用方式
以接口为例，匿名内部类的使用，代码如下：
创建匿名内部类，并调用：
通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：
到此基础班的知识学完了，从明天开始更新后续的知识，学如逆水行舟不进则退，既然学了，就坚持到底学习完。

什么是面向对象及其三个基本特性
面向对象
什么是对象？	一种具体存在的个体。
什么是类？ 把一部分相同或相似的对象抽象成一个类（型）。
如何定义类？	class 类名{属性；行为；}
如何创建对象？

对象的类型  对象的名字 = new 对象的类型（参数）；

接口名字   对象的名字 = new 对象的类型（参数）；

对象的父类名字  对象的名字 = new 对象的类型（参数）；

如何访问类中的对象？

对象的名字.成员变量；

对象的名字.方法名字（参数）；

三个基本特性：

封装：将数据及算法尽可能隐藏到类的内部，只暴露必须的操作方法和数据,可以提高软件的可靠性和安全。.

继承：复用,把子类中公共的属性和方法，“泛化”到父类中。（泛化：将子类的公共属性和方法抽取到

父类的过程成为泛化）

多态：子类对象指向父类引用。父类型变量引起的子类型个体是多种多样的，使用子类型方法时候，其功能也是多种多样的。