面向对象—封装—汽车

  1 /*
  2      * 按要求编写Java应用程序。 (1)创建一个叫做机动车的类:
  3      *  属性:车牌号(String),车速(int),载重量(double)
  4      * 功能:加速(车速自增)、减速(车速自减)、修改车牌号,查询车的载重量。
  5      *  编写两个构造方法:一个没有形参,在方法中将车牌号设置“XX1234”,速
  6      * 度设置为100,载重量设置为100;另一个能为对象的所有属性赋值;
  7      * (2)创建主类: 在主类中创建两个机动车对象。
  8      * 创建第一个时调用无参数的构造方法,调用成员方法使其车牌为“辽 A9752”,并让其加速。
  9      * 创建第二个时调用有参数的构造方法,使其车牌为“辽B5086”,车速为150, 载重为200,
 10      * 并让其减速。 输出两辆车的所有信息
 11      */
 12     //车牌
 13     //油箱容量
 14     private double YouXRL=40;
 15     //总里程数
 16     private double ZongLC=0;
 17     //百公里油耗
 18     private double YouH=10;
 19     //当前油量
 20     private double DangQYL=0;
 21
 22     public String getCheP() {
 23         return CheP;
 24     }
 25
 26     public void setCheP(String cheP) {
 27         CheP = cheP;
 28     }
 29
 30     public double getYouXRL() {
 31         return YouXRL;
 32     }
 33
 34     public void setYouXRL(double youXRL) {
 35         YouXRL = youXRL;
 36     }
 37
 38     public double getZongLC() {
 39         return ZongLC;
 40     }
 41
 42     public void setZongLC(double zongLC) {
 43         ZongLC = zongLC;
 44     }
 45
 46     public double getYouH() {
 47         return YouH;
 48     }
 49
 50     public void setYouH(double youH) {
 51         if(youH>0)
 52         {
 53         YouH = youH;
 54         }
 55         else
 56         {
 57             System.out.println("输入有误");
 58         }
 59     }
 60
 61     public double getDangQYL() {
 62         return DangQYL;
 63     }
 64
 65     public void setDangQYL(double dangQYL) {
 66         DangQYL = dangQYL;
 67     }
 68     private String CheP;
 69     public Car1(String cheP) {
 70         super();
 71         CheP = cheP;
 72     }
 73     //方法:加油
 74     public void JiaYou(double youl)
 75     {
 76         if(youl<0)
 77         {
 78             System.out.println("不要偷我的油");
 79         }
 80         else if(youl>(YouXRL-DangQYL))
 81         {
 82             DangQYL=YouXRL;
 83             System.out.println("油箱已满");
 84         }
 85         else
 86         {
 87             DangQYL+=youl;
 88             System.out.println("油量为:"+youl);
 89         }
 90     }
 91          //当前油量增加
 92         //加油方法的重载,一次加满了D
 93         public double JiaYou()
 94         {
 95             //返回值()得计算
 96             double rtn=YouXRL-DangQYL;
 97             JiaYou(rtn);//
 98             return rtn;
 99         }
100         //行驶
101         public void Xingshi(double Lingcheng)
102         {
103             if(Lingcheng>0)
104             {
105             //当前油量
106             DangQYL-=Lingcheng*YouH/100;
107             //总里程
108             ZongLC+=Lingcheng;
109             }
110             else
111             {
112                 System.out.println("车不能这样开");
113             }
114         }
115
116         public static void main(String[] args) {
117         // TODO 自动生成的方法存根
118         Car1 car=new Car1("鲁C12345");
119         car.setYouXRL(50);
120         System.out.println("油箱容量="+car.getYouXRL());
121         car.JiaYou(40);
122         System.out.println("当前容量"+car.getDangQYL());
123         car.JiaYou();
124         System.out.println("当前容量"+car.getDangQYL());
125         car.setYouH(7);
126         car.Xingshi(-100);
127         System.out.println("当前油量"+car.getDangQYL());
128         System.out.println("总里程"+car.getZongLC());
129     }

时间: 2024-10-05 21:06:25

面向对象—封装—汽车的相关文章

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