Java和Python的面向对象（你有对象吗？没有就来new一个）
Java和Python基础的面向对象
- 1. 面向对象
- 2. Java
- 2.1 Java封装
- 2.2 Java继承
- 2.3 Java多态
- 3. Python
- 3.1 Python封装
- 3.2 Python继承
- 3.3 Python多态
1. 面向对象
说到面向对象（OOP：Object Oriented Programming）就要先说面向过程(Procedure-Oriented Programming)
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向对象是把整个需求按照特点、功能划分，将这些存在共性的部分封装成对象，创建对象不是为了完成某一个步骤，而是描述某个事物在解决问题的步骤中的行为。
面向对象的优点：
- 良好的扩展性
- 分工明确
面向对象的主要特点：
- 封装
- 继承
- 多态
函数和面向对象的区别：
函数和面向对象的共同点是都把程序进行封装、方便重复利用，提高效率，避免代码冗余。不同点就是函数是一整段代码，不可修改，用于直接调用，而面向对象非常灵活，有继承，多态，重载等等
2. Java
构造方法：
每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
创建对象：
对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：
声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。
2.1 Java封装
/**
* @Author： FlynnLi
* @Description： 功能：简单类的定义、构造方法、创建对象、调用方法
* @Date： 2020/4/4 22:39
*/
class dog{
int dogAge;
public dog(String name){
// 这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public void setAge( int age ){
dogAge = age;
}
public int getAge( ){
System.out.println("小狗的年龄为 : " + dogAge );
return dogAge;
}
public static void main(String[] args){
/* 创建对象 */
dog myDog = new dog( "Tom" );
myDog.setAge( 2 );/* 通过方法来设定 age */
myDog.getAge( );/* 调用另一个方法获取age */
System.out.println("变量值 : " + myDog.dogAge );/*访问成员变量 */
}
}
2.2 Java继承
在 Java 中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。
利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
Java不支持多继承，可多重继承。
package com.classtest;
/**
* @Author ： FlynnLi
* @Date ： 2020/4/4 23:10
* @Description ： Dog类继承Animal类
*/
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
2.3 Java多态
多态是同一个行为具有多个不同表现形式或形态的能力，就是同一个接口，使用不同的实例而执行不同操作。
多态的实现方式：
方式一：重写：
这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。
方式二：接口
- 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
- java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。
方式三：抽象类和抽象方法
package com.classtest02;
/**
* @Author ： FlynnLi
* @Date ： 2020/4/5 0:06
* @Description ： 多态
*/
public class Test02 {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dogs()); // 以 Dog 对象调用 show 方法
Animals a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animals a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dogs) { // 狗做的事情
Dogs c = (Dogs)a;
c.work();
}
}
}
abstract class Animals {
abstract void eat();
}
class Cat extends Animals {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dogs extends Animals {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
3. Python
3.1 Python封装
使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。
简单类的定义：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/4/2 22:30
# @Author : FlynnLi
# @Description : 创建类，属性，方法，然后调用
class Person:
# 这是一个学习Python定义的一个Person类
# 下面定义了一个类变量
hair = 'black'
def __init__(self, name='张三', age=8):
# 下面为Person对象增加2个实例变量
self.name = name
self.age = age
def say(self, content):
print(self.name + "说：“" + content + "”")
p = Person() # 调用Person类的构造方法，返回一个Person对象,将该Person对象赋给p变量
print(p.name, p.age)
p.name = '李四' # 访问p的name实例变量，直接为该实例变量赋值
# 调用p的say()方法，声明say()方法时定义了2个形参
# 但第一个形参（self）是自动绑定的，因此调用该方法只需为第二个形参指定一个值
p.say('好好学习，天天向上！')
p.age = 18
print(p.name, p.age) # 李四 18
# 为p对象增加一个skills实例变量
p.skills = ['programming', 'reading']
print(p.skills)
del p.name
# print(p.name) # AttributeError 因为属性已经被删除了
3.2 Python继承
Python继承分为单继承和多继承，同样的是子承父类
单继承：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/4/2 22:56
# @Author : FlynnLi
# @Description : 单继承
class SchoolMember:
def __init__(self, name, gender):
self.name = name
self.gender = gender
def tell(self):
print("Name is %s, Gender is %s" % (self.name, self.gender))
class Teacher(SchoolMember):
def __init__(self, name, gender, title):
self.name = name
self.gender = gender
self.title = title
def tell(self):
print("Name is %s, Gender is %s, Title is %s" % (self.name, self.gender, self.title))
class Student(SchoolMember):
def __init__(self, name, gender, major):
self.name = name
self.gender = gender
self.major = major
def tell(self):
print("Name is %s, Gender is %s, Major is %s" % (self.name, self.gender, self.major))
t = Teacher("李老师", "男", "教授")
s = Student("李四", "男", "计算机科学与技术")
member = [t, s]
for item in member:
item.tell()
多继承：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/4/2 23:23
# @Author : FlynnLi
# @Description : 多继承
class Father:
def get(self):
print("I'm a father.")
class Mather:
def get(self):
print("I'm a mather.")
class Child(Father, Mather):
def __init__(self):
print("I'm a child.")
baby = Child()
baby.get()
# 因为多继承这块，同名方法函数优先使用靠前的类
3.3 Python多态
多个类有个公共的基类，他们有相同的形态或形式行为。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/4/2 23:56
# @Author : FlynnLi
# @Description : 多态
import math
class Shape:
def area(self):
print()
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
area_value = math.pi * self.radius * self.radius
print(area_value)
class Triangle(Shape):
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
def area(self):
p = (self.x + self.y + self.z) / 2
area_value = math.sqrt(p * (p - self.x) * (p - self.y) * (p - self.z))
print(area_value)
class Rectangle(Shape):
def __init__(self, x, y):
self.x = x
self.y = y
def area(self):
area_value = self.x * self.y
print(area_value)
o = Circle(2)
t = Triangle(3, 4, 5)
r = Rectangle(6, 7)
o.area()
t.area()
r.area()
Java还在学习阶段，勿喷。如有错误，可以帮我纠正。
Python使用老师上课的例子，有空下一次写飞机游戏的案例。