面向对象-封装

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5
  6 namespace 封装
  7 {     在其他类里引用
  8     class Student
  9     {
 10         //成员方法
 11         public void Write()
 12         {
 13             Console.WriteLine("我是Stu的Write方法!");
 14         }
 15
 16         /// <summary>
 17         /// 求和方法
 18         /// </summary>
 19         /// <param name="a">第一个数</param>
 20         /// <param name="b">第二个数</param>
 21         /// <returns></returns>
 22         public int Sum(int a,int b)
 23         {
 24             return a + b;
 25         }
 26
 27
 28
 29
 30
 31
 32         private string _Code;
 33
 34         public string Code
 35         {
 36             get
 37             {
 38                 return _Code;
 39             }
 40
 41             set
 42             {
 43                 _Code = value;
 44             }
 45         }
 46
 47         private string _Name;
 48
 49         /// <summary>
 50         /// 学生姓名
 51         /// </summary>
 52         public string Name
 53         {
 54             get { return _Name; }
 55             set { _Name = value; }
 56         }
 57
 58
 59
 60
 61
 62         private decimal _Score;
 63
 64         public decimal Score
 65         {
 66             get
 67             {
 68                 return _Score;
 69             }
 70             set
 71             {
 72                 if (value < 0 || value > 100)
 73                 {
 74                     _Score = 0;
 75                 }
 76                 else
 77                 {
 78                     _Score = value;
 79                 }
 80             }
 81         }
 82
 83
 84         private DateTime _Birthday;
 85
 86         public DateTime Birthday
 87         {
 88             get
 89             {
 90                 return _Birthday;
 91             }
 92             set
 93             {
 94                 _Birthday = value;
 95             }
 96         }
 97
 98         public string BirthdayStr
 99         {
100             get
101             {
102                 return _Birthday.ToString("yyyy年MM月dd日");
103             }
104         }
105
106         public string CodeAndScoreSum
107         {
108             get
109             {
110                 return _Code + _Score;
111             }
112         }
113
114
115     }
116 }
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5
 6 namespace 封装
 7 {
 8     class Teacher
 9     {第二个类
10         //构造函数
11         public Teacher()
12         {
13             _Name = "切西瓜";
14         }
15
16         private string _Name;
17
18         public string Name
19         {
20             get { return _Name; }
21             set { _Name = value; }
22         }
23
24
25     }
26 }
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5
 6 namespace 封装
 7 {
 8     class Program
 9     {
10         static void Main(string[] args)
11         {
12             Student s = new Student(); //实例化
13
14             s.Write();
15             int i = s.Sum(5, 5);
16
17             Console.WriteLine(i);
18
19             Teacher t = new Teacher();
20             Console.WriteLine(t.Name);
21
22
23
24
25             #region
26             //s.Code = "101";
27             //s.Score = 101;
28             //s.Birthday = DateTime.Now;
29             ////s.BirthdayStr = "";
30
31             //Console.WriteLine(s.Code);
32             //Console.WriteLine(s.Score);
33             //Console.WriteLine(s.Birthday);
34             //Console.WriteLine(s.BirthdayStr);
35             //Console.WriteLine(s.CodeAndScoreSum);
36             #endregion
37
38
39             Console.ReadLine();
40         }
41     }
42 }

时间: 2024-08-27 19:18:57

面向对象-封装的相关文章

python学习 面向对象封装

from collectoins import namedtuplePoint=namedtuple('point',['x','y'])t1=Point(1,2)print(t1.x)print(t1.y)没有方法的类属性不会发生变化    定义简单 不能改变面向对象封装私有属性!!!私有方法!!!用装饰器描述的几个方法@property !!!@classmethod!!@staticmethod! 封装:class Teacher:     def __init__(self,name,p

OC面向对象封装

OC面向对象封装 一.面向对象和封装 面向对象的三大特性:封装(成员变量),继承,多态 在OC语言中,使用@interface和@implementation来处理类. @interface就好像暴露在外面的时钟表面,像外界提供展示以及接口,@implementation就好像隐藏在时钟内部的构造实现,把具体的实现封装了起来. 二.Set方法 在研发过程中,考虑到安全性要求,我们一般不在成员变量名前面使用@public,@protected等关键字修饰,而是使用Set方法来为对象提供成员变量值,

面向对象 封装 、继承

构造函数: 构造函数 - 创建一个类的函数 每一个类都有构造函数,访问修饰符必须是public的,并且不需要写任何返回值,方法名与类名一致 自己写的类 - 用户自定义类型如果要使用自定义类型产生出来的  对象  必须有一个实例化的过程 实例化格式:类型名  ss = new 构造函数(); 访问修饰符 -  4个 public - 公共的,任何地方都可以访问,但是需要引用 命名空间 private - 私有的,类的内部才可以访问 internal - 内部的,默认的,程序集中可以访问,程序集就是

Java面向对象㈠ -- 封装

Java的面向对象有三大特征:封装.继承.多态.这里主要对封装进行讲解. 封装可以理解为隐藏一个类的成员变量和成员函数,只对外提供需要提供的成员函数. Java的封装主要通过访问权限控制符:private,默认,protected,public来实现.(这四个权限访问控制符的区别网上有很多,建议读者自行搜索学习,切记要亲自练习一下!)最明显的实现就是把类的成员变量私有(private),只能通过类的成员函数来进行访问,并且此时的成员函数公有(public).这就是著名的setter/getter

Atitit usbQb212 oo 面向对象封装的标准化与规范解决方案java c# php js

1.1. 封装性是面象对象编程中的三大特性之一  三个基本的特性:封装.继承与多态1 1.2. 魔术方法 预定义方法2 1.3. 魔术常量(Magic constants) 预定义变量2 1.4. 适用领域 js php java c#2 1.5. 构造函数 __construct( ) vs xxxCls()3 1.6. 析构函数名称必须是__destruct( )  finally()3 1.7. 私有属性 与工友属性3 1.8. $this指针3 1.9. __autoload() 类自动

使用java中,面向对象封装+继承的方法算题

1.第一种:给定一行字符,逆序输出此字符串(空格.数字不输出),如"ab 23,(4 cd"输出"dc(,ba".(要求:使用面向对象封装+继承) class Bu { private String str; public Bu(){} public Bu(String str){ this.str = str; } public String getStr(){ return str; } public void setStr(String str){ this.

面向对象封装的web服务器

import socket import re import os import sys # 由于前面太繁琐,可以用类封装一下,也可以分几个模块 class HttpServer(object): def __init__(self,port): # 1.服务器创建负责监听的socket self.socket_watch = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 2.设置地址重用 self.socket_watch.setsoc

php面向对象 封装继承多态 接口、重载、抽象类、最终类总结

1.面向对象 封装继承多态  接口.重载.抽象类.最终类 面向对象 封装继承多态  首先,在解释面向对象之前先解释下什么是面向对象? [面向对象]1.什么是类? 具有相同属性(特征)和方法(行为)的一系列个体的集合,类是一个抽象的概念2.什么是对象?从类中拿到的具有具体属性值得个体,称为对象,对象是一个具体的个体 所以,面向对象即我们专注对象来处理问题,通过从一个个具有属性和功能的类中拿到对象来处理问题. 下面我们再来细说下面向对象的三大特征:继承/封装/多态 一.继承 在PHP中我们主要通关E

面向对象封装、继承、多态

一.面向对象封装 01. 封装 封装 是面向对象编程的一大特点 面向对象编程的 第一步 —— 将 属性 和 方法 封装 到一个抽象的 类 中 外界 使用 类 创建 对象,然后 让对象调用方法 对象方法的细节 都被 封装 在 类的内部 02. 小明跑步案例 需求: 小明 体重 50公斤 小明每次 跑步 会减肥 1公斤 小明每次 吃东西 体重增加 0.5 公斤 class Person(object): def __init__(self, name, weight): self.name = na

python面向对象封装

# 面向对象封装案例:为新房子增添家具# 分析对象的属性# 房子属性:户型.面积 # 家具属性: 家具名称.占地面积 class Furniture: def __init__(self, name, area): self.name = name self.area = area def __str__(self): return F"[{self.name}]占地面积{self.area}平方米" class House: def __init__(self, house_type