他的最新文章
他的热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)韩顺平 java笔记 第9讲 第10讲 第11讲 第12讲
抽象 封装 继承 多态
方法重载 方法重写
时间： 12:58:16
&&&& 阅读：15
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&java面向对象编程的四大特征
& &抽象、封装、继承、多态
1.抽象：把一类事物的共同属性和行为提取出来，形成一个物理模拟，这种研究问题的方法。
2.封装：把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作（成员方法）
　　　才能对数据进行操作。
　2.1　& & public class Demo{
　　　　& public static void main(String[] args){
　　　　　　Clerk clerk1 = new Clerk("小花",24,4567.6f);
　　　　　　System.out.println("名字是"，+ clerk1.name + "薪水" + clerk1.getSal());
　　　class Clerk {
　　　　public S
&　　　& &
　　　　public Clerk(String name,int age,float sal){
　　　　　　this.name =
　　　　　　this.age =
　　　　　　this.salary =
　　&&　　public float getSal(){
　　　　　　return this.
　　2.2 访问修饰符
　　访问级别& 访问控制修饰符& 同类& 同包& 子类& 不同包
　　　　1　　　　public& & & & & & Y& & & & Y& & & &Y& & & & Y
& & & & & & & 2& & & & & & & protect& & & & & &Y& & & & Y& & & &Y& & & &N&&
　　　　3　　　没有修饰符& & & &Y　　 Y& & & &N& & & &N&
　　　　4& & & & & & & private& & & & & &Y&　　N　　N　　N
　　在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，之需要extends语句声明继承父类
*****子类最多只能继承一个父类（指直接继承）
　　java所有类都是Obiect类的子类
　　package com.
　　public class Demo117{
　　　　public static void main(String[] args){
　　　　　　Pupil p1 = new Pupil();
　　　　　　p1.printName();
　　class Stu{
　　　　public S
　　　　private S//私有不被继承，不希望继承某个属性和方法 就声明为private
　　　　public void printName(){
　　　　　　System.out.println("名字" + this.name);
　　class Pupil extends Stu{
　　　　public void pay(float fee){
　　　　　　this.fee=
　　class Pre extends Pupil{
　　　　public void pay(float fee){
　　　　　　this.fee=fee*1.5f;
　　<span style="color: #ff方法重载
　　　　（1）方法名相同
　　　　（2）方法的参数类型、个数、顺序、至少有一项不同。
　　　　（3）方法的返回类型可以不同
　　　　（4）方法的修饰符可以不同
　　4.2方法重写
　　　　（1）子类的方法的返回类型、参数、方法名称要和父类的一样
　　　　（2）子类方法不能缩小父类方法的访问权限
　　public class Demo{
　　　　public static void main(String[] args){
　　　　　　Cat cat1 = new Cat();
　　　　　　cat1.cry();
　　　　　　Dog dog1 = new Dog();
　　　　　　dog1.cry();
　　class Animal{
　　　　public void cry(){
　　　　　　System.out.println("我是动物，不知道叫");
　　class Cat extends Animal{
　　　　public void cry(){
　　　　　　System.out.println("猫猫叫");
　& & class Dog extends Animal{
　　　　public void cry(){
　　　　　　System.out.println("狗叫");
******super.调用父类XXX的变量或方法引用。
******super.xxx（）;直接访问调用父类的方法。
******super（）;调用父类初始化方法public xxx()方法。
　　　　<span style="color: #ff 多态
　　public class Demo123{
　　　　public static void main(String[] args){
　　　　　　Animal an = new Cat();
　　　　　　an.cry();
　　　　　　an = new Dog();
　　　　　　an.cry();　
　　　　　　Master master = new Master();
　　　　　　master.feed(new Dog(),new Bone());
　　　　　　master.feed(new Cat(),new Fish());
　　class Master{
　　　　public void feed (Animal an,Food f);
　　　　an.eat();
　　　　f.showName();
　　class Animal (){
　　　　public void eat(){
　　class Dog extends Animal (){
　　　　public void eat(){
　　class Cat Extends Animal (){
　　　　public void eat(){
　　class Food{
　　　　public void show Name(){
　　class Fish extends Food{
　　　　public void show Name(){
　& class& Bone extends Food{
　　　　public void show Name(){
&标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&原文：https://www.cnblogs.com/wangxiaoli/p/8548604.html
教程昨日排行
&&国之画&&&& &&&&&&
&& &&&&&&&&&&&&&&
鲁ICP备号-4
打开技术之扣，分享程序人生！四、类与对象（二） - 酱紫安 - 博客园
随笔 - 24, 文章 - 0, 评论 - 8, 引用 - 0
保护对象的属性
如果有一个对象，当需要对其进行修改属性时，有2种方法
对象名.属性名 = 数据 ----&直接修改
对象名.方法名() ----&间接修改
为了更好的保存属性安全，即不能随意修改，一般的处理方式为
将属性定义为私有属性
添加一个可以调用的方法，供调用
1 class People(object):
def __init__(self, name):
self.__name = name
def getName(self):
return self.__name
def setName(self, newName):
<span style="color: #
if len(newName) &= 5:
<span style="color: #
self.__name = newName
<span style="color: #
<span style="color: #
print("error:名字长度需要大于或者等于5")
<span style="color: #
<span style="color: # man = People("jiangzi")
<span style="color: # print(man.__name)
Traceback (most recent call last):
File "F:/plane/test.py", line 16, in &module&
print(man.__name)
AttributeError: 'People' object has no attribute '__name'
1 class People(object):
def __init__(self, name):
self.__name = name
def getName(self):
return self.__name
def setName(self, newName):
<span style="color: #
if len(newName) &= 5:
<span style="color: #
self.__name = newName
<span style="color: #
<span style="color: #
print("error:名字长度需要大于或者等于5")
<span style="color: #
<span style="color: # man = People("jiangzi")
<span style="color: # print(man.getName())
<span style="color: #
<span style="color: # man.setName("hello")
<span style="color: # print(man.getName())
<span style="color: #
<span style="color: # man.setName("an")
<span style="color: # print(man.getName())
error:名字长度需要大于或者等于5
Python中没有像C++中public和private这些关键字来区别公有属性和私有属性
它是以属性命名方式来区分，如果在属性名前面加了2个下划线'__'，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。
类的特殊成员方法
1. __doc__　　表示类的描述信息
2.&__module__ 和 &__class__&
　　__module__ 表示当前操作的对象在那个模块
　　__class__ & & 表示当前操作的对象的类是什么
&lib/aa.py
3. __init__ 构造方法，通过类创建对象时，自动触发执行。
　析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的　
当有1个变量保存了对象的引用时，此对象的引用计数就会加1
当使用del删除变量指向的对象时，如果对象的引用计数不会1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除
5. __call__&对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
6. __dict__ 查看类或对象中的所有成员&　　
7.__str__&如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
8.__getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
9. __new__ \ __metaclass__
1 # 定义一个父类，如下:
2 class Cat(object):
def __init__(self, name, color="白色"):
self.name = name
self.color = color
def run(self):
print("%s--在跑"%self.name)
<span style="color: #
<span style="color: #
<span style="color: # # 定义一个子类，继承Cat类如下:
<span style="color: # class SubCat(Cat):
<span style="color: #
<span style="color: #
def setNewName(self, newName):
<span style="color: #
self.name = newName
<span style="color: #
<span style="color: #
def eat(self):
<span style="color: #
print("%s--在吃"%self.name)
<span style="color: #
<span style="color: #
<span style="color: # cat = SubCat("印度猫")
<span style="color: # print('cat的名字为:%s' % cat.name)
<span style="color: # print('cat的颜色为:%s' % cat.color)
<span style="color: # cat.eat()
<span style="color: # cat.setNewName('波斯猫')
<span style="color: # cat.run()
cat的名字为:印度猫
cat的颜色为:白色
印度猫--在吃
波斯猫--在跑
虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法
子类在继承的时候，在定义类时，小括号()中为父类的名字
父类的属性、方法，会被继承给子类
私有的属性，不能通过对象直接访问，但是可以通过方法访问
私有的方法，不能通过对象直接访问
私有的属性、方法，不会被子类继承，也不能被访问
一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用
1 class Animal(object):
def __init__(self, name='动物', color='白色'):
self.__name = name
self.color = color
def __test(self):
print(self.__name)
print(self.color)
<span style="color: #
<span style="color: #
def test(self):
<span style="color: #
print(self.__name)
<span style="color: #
print(self.color)
<span style="color: #
<span style="color: #
<span style="color: #
<span style="color: # class Dog(Animal):
<span style="color: #
def dogTest1(self):
<span style="color: #
#print(self.__name) #不能访问到父类的私有属性
<span style="color: #
print(self.color)
<span style="color: #
<span style="color: #
<span style="color: #
def dogTest2(self):
<span style="color: #
#self.__test() #不能访问父类中的私有方法
<span style="color: #
self.test()
<span style="color: #
<span style="color: #
<span style="color: # A = Animal()
<span style="color: # #print(A.__name) #程序出现异常，不能访问私有属性
<span style="color: # print(A.color)
<span style="color: # #A.__test() #程序出现异常，不能访问私有方法
<span style="color: # A.test()
<span style="color: #
<span style="color: # print("------分割线-----")
<span style="color: #
<span style="color: # D = Dog(name = "小花狗", color = "黄色")
<span style="color: # D.dogTest1()
<span style="color: # D.dogTest2()
------分割线-----
多继承（经典类：深度优先，新式类：广度优先）
简单示例：
# 定义一个父类
def printA(self):
print('----A----')
# 定义一个父类
def printB(self):
print('----B----')
# 定义一个子类，继承自A、B
class C(A,B):
def printC(self):
print('----C----')
obj_C = C()
obj_C.printA()
obj_C.printB()
python中是可以多继承的
父类中的方法、属性，子类会继承
如果在上面的多继承例子中，如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个？继承顺序是怎么样的？
1 #coding=utf-8
2 class base(object):
def test(self):
print('----base test----')
5 class A(base):
def test(self):
print('----A test----')
9 # 定义一个父类
<span style="color: # class B(base):
<span style="color: #
def test(self):
<span style="color: #
print('----B test----')
<span style="color: #
<span style="color: # # 定义一个子类，继承自A、B
<span style="color: # class C(A,B):
<span style="color: #
<span style="color: #
<span style="color: #
<span style="color: # obj_C = C()
<span style="color: # obj_C.test()
<span style="color: #
<span style="color: # print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序
----A test----
(&class '__main__.C'&, &class '__main__.A'&, &class '__main__.B'&, &class '__main__.base'&, &class 'object'&)
重写父类方法
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
调用父类的方法
调用父类的__init__方法1(python2)
父类.__init__(self,name)
调用父类的__init__方法2
super(子类,self).__init__(name)
调用父类的__init__方法3
super().__init__(name)
类属性、实例属性
1 class People(object):
name = 'Tom'
#公有的类属性
__age = 12
#私有的类属性
5 p = People()
7 print(p.name)
8 print(People.name)
9 print(p.__age)
#错误，不能在类外通过实例对象访问私有的类属性
<span style="color: # print(People.__age)
#错误，不能在类外通过类对象访问私有的类属性
1 class People(object):
address = '山东' #类属性
def __init__(self):
self.name = 'xiaowang' #实例属性
self.age = 20 #实例属性
7 p = People()
8 p.age =12 #实例属性
9 print(p.address) #正确
<span style="color: # print(p.name)
<span style="color: # print(p.age)
<span style="color: #
<span style="color: # print(People.address) #正确
<span style="color: # print(People.name)
<span style="color: # print(People.age)
&如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。
通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法，什么是静态方法呢？其实不难理解，普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法
class Dog(object):
def __init__(self,name):
self.name = name
@staticmethod #把eat方法变为静态方法
def eat(self):
print("%s is eating" % self.name)
d = Dog("ChenRonghua")
上面的调用会出以下错误，说是eat需要一个self参数，但调用时却没有传递，没错，当eat变成静态方法后，再通过实例调用时就不会自动把实例本身当作一个参数传给self了。
Traceback (most recent call last):
File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/静态方法.py", line 17, in &module&
TypeError: eat() missing 1 required positional argument: 'self'&
想让上面的代码可以正常工作有两种办法
1. 调用时主动传递实例本身给eat方法，即d.eat(d)&
2. 在eat方法中去掉self参数，但这也意味着，在eat中不能通过self.调用实例中的其它变量了
1 class Dog(object):
def __init__(self,name):
self.name = name
@staticmethod
def eat():
print(" is eating")
12 d = Dog("ChenRonghua")
13 d.eat()
类方法　　
类方法通过@classmethod装饰器实现，类方法和普通方法的区别是， 类方法只能访问类变量，不能访问实例变量
class Dog(object):
def __init__(self,name):
self.name = name
@classmethod
def eat(self):
print("%s is eating" % self.name)
d = Dog("ChenRonghua")
&执行报错如下，说Dog没有name属性，因为name是个实例变量，类方法是不能访问实例变量的
Traceback (most recent call last):
File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/类方法.py", line 16, in &module&
File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/类方法.py", line 11, in eat
print("%s is eating" % self.name)
AttributeError: type object 'Dog' has no attribute 'name'
此时可以定义一个类变量，也叫name,看下执行效果
class Dog(object):
name = "我是类变量"
def __init__(self,name):
self.name = name
@classmethod
def eat(self):
print("%s is eating" % self.name)
d = Dog("ChenRonghua")
我是类变量 is eating
View Code&
属性方法　　
属性方法的作用就是通过@property把一个方法变成一个静态属性
1 class Dog(object):
def __init__(self,name):
self.name = name
def eat(self):
print(" %s is eating" %self.name)
<span style="color: #
<span style="color: # d = Dog("ChenRonghua")
<span style="color: # d.eat()
调用会出以下错误， 说NoneType is not callable, 因为eat此时已经变成一个静态属性了， 不是方法了， 想调用已经不需要加()号了，直接d.eat就可以了
Traceback (most recent call last):
ChenRonghua is eating
File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/属性方法.py", line 16, in &module&
TypeError: 'NoneType' object is not callable
正常调用如下
d = Dog("ChenRonghua")
ChenRonghua is eating
通过字符串映射或修改程序运行时的状态、属性、方法, 有以下4个方法
def getattr(object, name, default=None): # known special case of getattr
getattr(object, name[, default]) -& value
Get a named attr getattr(x, 'y') is equivalent to x.y.
When a default argument is given, it is returned when the attribute doesn't
without it, an exception is raised in that case.
判断object中有没有一个name字符串对应的方法或属性
def setattr(x, y, v): # re restored from __doc__
Sets the named attribute on the given object to the specified value.
setattr(x, 'y', v) is equivalent to ``x.y = v''
def delattr(x, y): # re restored from __doc__
Deletes the named attribute from the given object.
delattr(x, 'y') is equivalent to ``del x.y''
1 class Foo(object):
def __init__(self):
self.name = 'wupeiqi'
def func(self):
return 'func'
9 obj = Foo()
<span style="color: #
<span style="color: # # #### 检查是否含有成员 ####
<span style="color: # hasattr(obj, 'name')
<span style="color: # hasattr(obj, 'func')
<span style="color: #
<span style="color: # # #### 获取成员 ####
<span style="color: # getattr(obj, 'name')
<span style="color: # getattr(obj, 'func')
<span style="color: #
<span style="color: # # #### 设置成员 ####
<span style="color: # setattr(obj, 'age', 18)
<span style="color: # setattr(obj, 'show', lambda num: num + 1)
<span style="color: #
<span style="color: # # #### 删除成员 ####
<span style="color: # delattr(obj, 'name')
<span style="color: # delattr(obj, 'func')【学习笔记】【OC语言】多态_iOS开发_动态网站制作指南
【学习笔记】【OC语言】多态
来源：人气：945
1.多态的基本概念某一类事物的多种形态OC对象具有多态性
2.多态的体现Person *p = [Student new];p-&age = 100;[p walk];子类对象赋值给父类指针父类指针访问对应的属性和方法
3.多态的好处用父类接收参数，节省代码
4.多态的局限性不能访问子类的属性（可以考虑强制转换）
5.多态的细节动态绑定：在运行时根据对象的类型确定动态调用的方法
1 #import &Foundation/Foundation.h&
1.没有继承就没有多态
2.代码的体现：父类类型的指针指向子类对象
3.好处：如果函数\方法参数中使用的是父类类型，可以传入父类、子类对象
4.局限性：
1& 父类类型的变量 不能 直接调用子类特有的方法。必须强转为子类类型变量后，才能直接调用子类特有的方法
12 // 动物
13 @interface Animal : NSObject
14 - (void)
17 @implementation Animal
18 - (void)eat
NSLog(@"Animal-吃东西----");
25 @interface Dog : Animal
26 - (void)
29 @implementation
30 - (void)run
NSLog(@"Dog---跑起来");
34 - (void)eat
NSLog(@"Dog-吃东西----");
41 @interface Cat : Animal
45 @implementation Cat
46 - (void)eat
NSLog(@"Cat-吃东西----");
52 // 这个函数是专门用来喂动画
53 //void feed(Dog *d)
58 //void feed2(Cat *c)
64 // 如果参数中使用的是父类类型，可以传入父类、子类对象
65 void feed(Animal *a)
70 int main()
// NSString *d = [Cat new];
// [d eat];
Animal *aa = [Dog new];
// 多态的局限性：父类类型的变量 不能 用来调用子类的方法
//[aa run];
// 将aa转为Dog *类型的变量
Dog *dd = (Dog *)
//Dog *d = [Dog new];
//[d run];
Animal *aa = [Animal new];
Dog *dd = [Dog new];
Cat *cc = [Cat new];
// NSString *s = [Cat new];
Animal *c = [Cat new];
NSObject *n = [Dog new];
NSObject *n2 = [Animal new];
// 多种形态
//Dog *d = [Dog new]; // Dog类型
// 多态：父类指针指向子类对象
Animal *a = [Dog new];
// 调用方法时会检测对象的真实形象
优质网站模板