为了账号安全,请及时绑定邮箱和手机立即绑定

Java入门第二季

小慕 JAVA开发工程师
难度入门
时长 4小时 0分
学习人数
综合评分9.57
2064人评价 查看评价
9.8 内容实用
9.5 简洁易懂
9.4 逻辑清晰
  • 1、继承的概念:继承是类与类的一种关系;Java中的继承是单继承,只有一个父类。 2、继承的好处:子类直接拥有父亲的所有属性和方法。---private实现的无效! 代码可复用。 class 子类 extends 父类{……}
  • 1、调用外部内的成员变量:外部内名.this.变量名 2、创建内部类的对象:外部内对象.new 内部类()
  • package com.imooc;

    public class Car {
     private int cargo;//载货量
     private int carPerson;//载人量
     private String carName;//车名
     private int rentMoney;//租金

     //使用set、get方法读写属性
     public void setCargo(int cargo) {
      this.cargo=cargo;
     }
     public int getCargo() {
      return cargo;
     }
     public void setcarPerson(int carPerson) {
      this.carPerson=carPerson;
     }
     public int getcarPerson() {
      return carPerson;
     }
     public void setcarName(String carName) {
      this.carName=carName;
     }
     public String getcarName() {
      return carName;
     }
     public void setrentMoney(int rentMoney) {
      this.rentMoney=rentMoney;
     }
     public int getrentMoney() {
      return rentMoney;
     }
    }

    public class passengerCar extends Car {
     public passengerCar(String carName,int cargo,int carPerson,int rentMoney) {
      this.setCargo(cargo);
      this.setcarName(carName);
      this.setcarPerson(carPerson);
      this.setrentMoney(rentMoney);
     }
     //toString方法通常只是为了方便输出,在屏幕上显示出来。重写toString方法返回乘客车车辆信息
     public String toString() {
      return this.getcarName()+"载重:"+this.getCargo()+"t,载人"+
          this.getcarPerson()+"个人,租金"+this.getrentMoney();
     }
    }

    public class Truck extends Car {
     public Truck(String carName,int cargo,int carPerson,int rentMoney) {
      this.setCargo(cargo);
      this.setcarName(carName);
      this.setcarPerson(carPerson);
      this.setrentMoney(rentMoney);
     }
     //toString方法通常只是为了方便输出,在屏幕上显示出来。重写toString方法返回货车车辆信息
     public String toString() {
      return this.getcarName()+"载重:"+this.getCargo()+"t,载人"+
           this.getcarPerson()+"个人,租金"+this.getrentMoney();
     }
    }

    public class Pickup extends Car {
     public Pickup(String carName,int cargo,int carPerson,int rentMoney) {
      this.setCargo(cargo);
      this.setcarName(carName);
      this.setcarPerson(carPerson);
      this.setrentMoney(rentMoney);
     }
     //toString方法通常只是为了方便输出,在屏幕上显示出来。重写toString方法返回皮卡车车辆信息
     public String toString() {
      return this.getcarName()+"载重:"+this.getCargo()+"t,载人"+
           this.getcarPerson()+"个人,租金"+this.getrentMoney();
     }
    }


    import java.util.Scanner;

    public class dadaText {
     public static void main(String[] args) {
      //利用多态性,对各类车实例化并保存到数组
      Car[] cars= {
       new passengerCar("奥迪A4", 0, 4, 400),
       new passengerCar("金龙", 0, 10, 600),
       new Truck("松花江", 4, 0, 400),
       new Truck("依维柯", 30, 0, 800),
       new Pickup("皮卡雪6", 2, 4, 500),
       new Pickup("皮卡车", 4, 20, 1000),
      };
      //进入提示显示步骤
      System.out.println("欢迎使用达达租出系统!");
      System.out.println("是否租车:yes/no");
      //读取用户键入的信息并判断
      Scanner input=new Scanner(System.in);
      String t=input.next();
      if("yes".equals(t)) {
       System.out.println("您可租的车型及价目表如下:");
       System.out.println("序号"+"\t车名"+"\t\t载人数(人)"+"\t载货量(吨)"+"\t租金(元/天)");
       //输出实例化的各类车
       for(int i=0;i<cars.length;i++){
        System.out.println((i+1)+"\t"+cars[i]);//调用println函数时会自动调用toString()方法,使其在屏幕中显示出来
       }
       //租车的数量以及哪种车型
       System.out.println("请输入要租车的数量:");
       int carNum=input.nextInt();
       Car[] newCars = new Car[carNum];
       for(int j=0;j<carNum;j++) {
        System.out.println("请输入第"+(j+1)+"序号");
        int yy=input.nextInt();
        newCars[j]=cars[yy-1];
       }
       //租车的天数
       System.out.println("请输入要租车的天数");
       int times=input.nextInt();
       
       //输出账单
       int totalRent=0;
       int totalCargo=0;
       int totalPerson=0; 
       System.out.println("您本次的租车账单:"+"/n");
       System.out.println("此次选用车型"+"/n");
       for(int i=0;i<carNum;i++)
       {
        System.out.println(newCars[i].getcarName()+"/t");
        totalCargo+=newCars[i].getCargo();
        totalPerson+=newCars[i].getcarPerson();
        totalRent+=newCars[i].getrentMoney()*times;
       }
       System.out.print("\n");
       System.out.println("共可载客"+totalPerson+"人");
       System.out.println("共可载货"+totalCargo+"吨");
       System.out.println("请付租金"+totalRent+"元");
       System.out.print("\n");
       System.out.print("谢谢惠顾,欢迎下次光临");
       input.close();
      }
     }
    }


  • 如果我们直接在代码中直接输出一个对象,会发现它输出的是对象在内存中的地址,我们称其为哈希码(对象地址字符串,是用来唯一区分对象的,就好比我们使用的身份证号码)。如果我们希望在输出一个对象的时候能够直接输出对象的属性值,就需要重写toString方法(只有父类是Object的类才可以重写toString方法,因为toString方法是Object类的方法)。
  • 啪啪租车系统 代码1: http://hubojing.github.io/2017/03/18/%E8%BE%BE%E8%BE%BE%E7%A7%9F%E8%BD%A6%E7%B3%BB%E7%BB%9F%EF%BC%88Java%E5%AE%9E%E7%8E%B0%EF%BC%89/ 代码2: http://www.imooc.com/article/16922 代码3: www.imooc.com/article/16880 代码4: 参考了代码http://blog.csdn.net/Joseph_Cherry/article/details/60530978 自己的项目https://code.csdn.net/example440982/dadacar/tree/master 代码5: http://www.imooc.com/article/16652%20%20%20Java 运用接口: 1,http://www.imooc.com/article/16376 2,http://www.imooc.com/article/17018
  • 1.语法层面上的区别   1)抽象类可以提供成员方法的实现细节,而接口中只能存在public abstract 方法;   2)抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public static final类型的;   3)接口中不能含有静态代码块以及静态方法,而抽象类可以有静态代码块和静态方法;   4)一个类只能继承一个抽象类,而一个类却可以实现多个接口。 2.设计层面上的区别   1)抽象类是对一种事物的抽象,即对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。举个简单的例子,飞机和鸟是不同类的事物,但是它们都有一个共性,就是都会飞。那么在设计的时候,可以将飞机设计为一个类Airplane,将鸟设计为一个类Bird,但是不能将 飞行 这个特性也设计为类,因此它只是一个行为特性,并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly,包含方法fly( ),然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机,比如战斗机、民用飞机等直接继承Airplane即可,对于鸟也是类似的,不同种类的鸟直接继承Bird类即可。从这里可以看出,继承是一个 "是不是"的关系,而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类,则子类必定是抽象类的种类,而接口实现则是有没有、具备不具备的关系,比如鸟是否能飞(或者是否具备飞行这个特点),能飞行则可以实现这个接口,不能飞行就不实现这个接口。   2)设计层面不同,抽象类作为很多子类的父类,它是一种模板式设计。而接口是一种行为规范,它是一种辐射式设计。什么是模板式设计?最简单例子,大家都用过ppt里面的模板,如果用模板A设计了ppt B和ppt C,ppt B和ppt C公共的部分就是模板A了,如果它们的公共部分需要改动,则只需要改动模板A就可以了,不需要重新对ppt B和ppt C进行改动。而辐射式设计,比如某个电梯都装了某种报警器,一旦要更新报警器,就必须全部更新。也就是说对于抽象类,如果需要添加新的方法,可以直接在抽象类中添加具体的实现,子类可以不进行变更;而对于接口则不行,如果接口进行了变更,则所有实现这个接口的类都必须进行相应的改动。
  • 代码1 package com.imooc; public abstract class Human { public abstract void chinese(); public abstract void americans(); } package com.imooc; public class Language extends Human { public void chinese() { // TODO Auto-generated method stub System.out.println("中国人说汉语"); } @Override public void americans() { // TODO Auto-generated method stub System.out.println("美国人说英语"); } } package com.imooc; public class Test { public static void main(String args[]){ Human obj1 = new Language(); obj1.chinese(); obj1.americans(); } }
  • UML: 1、概念:Unified Modeling Language(UML)统一建模语言或标准建模语言 2、三种常用的UML图: ·用例图(The Use Case Diagram):关注功能,描述系统中出现的角色,以及它所需要的功能。 ·序列图(The Sequence Diagram):关注顺序,描述用户和系统中对象的交互环节:步骤和顺序 ·类图(The Class Diagram):关注关系:描述类和类之间的关系(继承等),表现类的属性和方法 3.UML建模工具:如Visio、Rational Rose、PowerDesiner
  • Super关键字:在对象内部使用,代表父类对象 访问父类的属性super.age 访问父类方法super.eat(); 子类构造过程中必须调用父类的构造方法:隐示super();显示调用父类构造方法,必须放在构造方法的第一行 当子类构造方法中既没有显示调用父类的构造方法,父类又没有无参的构造方法则编译出错
    07:12
    看视频
  • 问:什么是内部类呢? 答:内部类( Inner Class )就是定义在另外一个类里面的类。与之对应,包含内部类的类被称为外部类。 问:那为什么要将一个类定义在另一个类里面呢?清清爽爽的独立的一个类多好啊!! 答:内部类的主要作用如下: 1. 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类 2. 内部类的方法可以直接访问外部类的所有数据,包括私有的数据 3. 内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便 问:内部类有几种呢? 答:内部类可分为以下几种: ◦成员内部类 ◦静态内部类 ◦方法内部类 ◦匿名内部类
  • 1-3 如何使用Java中的对象 ⑴使用对象的步骤: ①创建对象: 类名 对象名= new 类名();//对一个类实例化 Telphone phone = new Telphone(); ②使用对象: 引用对象的属性:对象名.属性 phone.screen = 5;//给screen属性赋值5 引用对象的方法:对象名.方法 phone.sendMessage();//调用sendMessage()方法 例: package com.imooc; public class InitailTelphone { public static void main(String[] args) { // TODO Auto-generated method stub Telphone phone=new Telphone(); phone.sendMessage(); //给实例变量赋值 phone.screen=5.0f; phone.cpu=1.4f; phone.mem=2.0f; //调用对象的方法 phone.sendMessage(); } }
  • 接口 1.接口可以理解为一种特殊的类,由全局常量和公共的抽象方法所组成。 2.接口的概念 类是一种具体实现体,而接口定义了某一批类所需要遵守的规范,接口不关心这些类里方法的实现细节 ,它只规定这些类里必须提供某些方法。 3.接口定义使用interface 关键字。 接口 -> 是个规范 约束类 [修饰符] interface 借口名 [extends 父接口1,父接口2] { 零个到多个常量定义 public static final 零个到多个抽象方法定义 public abstract } 接口就是用来被继承 被实现的 修饰符一般建议用public 不能使用private 和 protected 类是单继承的 接口是可以多继承的 接口的引用 指向一个实现了接口的对象 IPlayGame ip1=new SmartPhone(); IPalyGame ip2=new Psp(); ip1.playGame(); ip2.playgame(); 匿名内部类: Interface i=new Interface(){ public void method(){ System.out.println("匿名内部类实现接口的方式"); } }; ip3.playGame(); 或者: new IPlaygame(){ public void playGame(){ System.out.println("使用匿名内部类的方式实现接口2"); } }.playgame();
  • 滴滴租车代码,应该算是比较简便了的(有每一步的说明),希望对你们有帮助

    package lx3;


    import java.util.Scanner;


    //汽车类

     class qc{


    private String qcmc;

    private int zhujin;

    private int rongli;

    private int dun;

    public qc(){

    }

    public qc(String qcmc,int zhujin,int rongli,int dun){

    this.qcmc=qcmc;

    this.zhujin=zhujin;

    this.rongli=rongli;

    this.dun=dun;

    }


    public String getqcmc(){

    return qcmc;

    }

    public int getzhujin() {

    return zhujin;

    }

    public int getrongli() {

    return rongli;

    }

    public int getdun(){

    return dun;

    }

     }

    //第一辆车的类

    class yiqc extends qc{

    public yiqc(){

    }

    public yiqc(String qcmc,int zhujin,int rongli,int dun){

    super(qcmc,zhujin,rongli,dun);

    }

    }

    //第二辆车

    class erqc extends qc{

    public erqc(){

    }

    public erqc(String qcmc,int zhujin,int rongli,int dun){

    super(qcmc,zhujin,rongli,dun);

    }

    }

    //第三辆车

    class sanqc extends qc{

    public sanqc(){

    }

    public sanqc(String qcmc,int zhujin,int rongli,int dun){

    super(qcmc,zhujin,rongli,dun);

    }

    }

    //第四辆车

    class siqc extends qc{

    public siqc(){

    }

    public siqc(String qcmc,int zhujin,int rongli,int dun){

    super(qcmc,zhujin,rongli,dun);

    }

    }

    //第五辆车

    class wuqc extends qc{

    public wuqc(){

    }

    public wuqc(String qcmc,int zhujin,int rongli,int dun){

    super(qcmc,zhujin,rongli,dun);

    }

    }

    //第六辆车

    class luqc extends qc{

    public luqc(){

    }

    public luqc(String qcmc,int zhujin,int rongli,int dun){

    super(qcmc,zhujin,rongli,dun);

    }

    }


    public class dididache {


    public static void main(String[] args) {

    // TODO Auto-generated method stub

    System.out.println("您是否要租车:1是    0否");

    //输入1或0

    Scanner sc=new Scanner(System.in);

    int i=sc.nextInt();

    //判断输入的是1还是0

    if(i==0) {

    System.out.println("感谢你的访问,欢迎下次再来");

    }else if(i==1) {

    System.out.println("你可租车的类型及其价目表");

    //用数组创建多个对象和用多态的引用可以指向子类的知识

    qc[] r1= {new yiqc("宝马",500,4,0),new erqc("奔驰",400,4,0),new sanqc("法拉利",450,4,2),new siqc("保时捷",800,20,0),new wuqc("兰博基尼",400,0,4),new luqc("麦凯轮",1000,0,20)};

    //用for循环输出租车价目表

    System.out.println("序号                汽车名称              租金          容量");

    for(int j=0;j<=5;j++) {

    System.out.println(j+1+"\t"+ r1[j].getqcmc()+"\t"+r1[j].getzhujin()+"\t"+"载人"+r1[j].getrongli()+" "+"载货"+r1[j].getdun()+"吨");

    }

    //输入汽车的数量

    System.out.println("请输入您要租汽车的数量");

    Scanner sc1=new Scanner(System.in);

    int x=sc1.nextInt();

    //定义一个数组用来储存选车的序号,数组的长度由租车的数量来决定

    //用for循环输出选择的车序号

    int[] sl=new int[x];

    for(int j=1;j<=sl.length;j++) 

    {

    System.out.println("请输入第"+j+"辆车的序号");

    Scanner sc2=new Scanner(System.in);

    int x1=sc2.nextInt();

    sl[j-1]=x1;

    }

    //输出租车的天数

    System.out.println("请输入您要租的天数");

    Scanner sc2=new Scanner(System.in);

    int y=sc2.nextInt();

    //计算账单

    System.out.println("您的账单");

    int num=0;

    for(int z=0;z<sl.length;z++) {

    num+=r1[sl[z]-1].getzhujin(); //sl[z]表示sl数组中的选的车序号

     //sl[z]-1表示车序号-1;因为车序号是1-6,而sl数组下标要0-5.

    //输出账单

    System.out.println("你一共需要支付:"+(num*y));  //y是租的天数

    }

      }


    }


  • /** * 建父类文件Car,再建三个子类文件,分别是:Huoche,Keche,Pikache * 定义父类拥有三个子类都有的属性,分别是:列序号number,品牌pinpai,车的每天租金zujin,车的载人容量zairen,车的载货容量zaihuo * 自定义父类的三个带参构造方法接收属性赋值,让子类创建对象并赋值时对号入座,每个子类只需用到一个构造方法 * 定义父类的普通方法,打印以上各个属性的值 * 创建程序入口文件 */
  • -----接口-----接口取名字一般前面加一个IPlayGame 1.接口概念 类是一种具体实现体,而接口定义了某一批类所需要遵守的规范,接口不关心这些类的内部数据,也不关心这些类里方法的实现细节,它只规定这些类里必须提供某些方法。 2.接口的定义 和类定义不同,定义接口不再使用class关键字,而是使用interface关键字。 3.接口定义的基本语法: [修饰符] [abstract] interface 接口名 [extends 父接口1,父接口2...] { 零个到多个常量定义... 零个到多个抽象方法的定义...(抽象方法的abstract会自动加) } 接口就是用来被继承、被实现的,修饰符一般建议用public 注意:不能使用private和protected修饰接口 4.使用接口 一个类可以实现一个或多个接口,实现接口使用implements关键字。Java中一个类只能继承一个父类,是不够灵活的,通过实现多个接口可以做补充。 [修饰符] class 类名 extends 父类 implement 接口1,接口2... { 类体部分//如果继承了抽象类,需要实现继承的抽象方法;要实现接口中的抽象方法。 } 接口的引用: IPlayGame ip1=new SmartPhone(); ip1.playGame(); IPlayGame ip2=new Psp(); ip2.playGame();
    05:40
    看视频

举报

0/150
提交
取消
课程须知
本课程是Java开发的基础,需要大家:掌握 Java 基本语法的使用。如果您是新手,建议先移步 《Java入门第一季》
老师告诉你能学到什么?
• 掌握 Java 基本语法和编程思路 • 熟练运用面向对象程序设计思想

微信扫码,参与3人拼团

意见反馈 帮助中心 APP下载
官方微信
友情提示:

您好,此课程属于迁移课程,您已购买该课程,无需重复购买,感谢您对慕课网的支持!