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

Java入门第二季

小慕 JAVA开发工程师
难度入门
时长 4小时 0分
学习人数
综合评分9.57
2050人评价 查看评价
9.8 内容实用
9.5 简洁易懂
9.4 逻辑清晰
  • 1.对象的概念 客观存在的是事物皆为对象。 具体存在事物为对象。 2.面向对象 人更关注具体事物的信息。 描述买电话的过程称为面向对象。 3.类 模型,用来描述对象的特征(属性)和行为(方法)。 对象就是计算机中的具体信息。 累就是这个信息的类型。 具有相同属性和方法的一组对象的集合。 4.对象的属性 对象拥有的各种特征(有什么)。 例如手机的屏幕,cpu,内存等等。 5.对象的方法 对象执行的操作(能干什么)。 6。类和对象的关系/区别 类是抽象的概念,模板。描述具体的对象信息。 对象是具体实体,客观存在。
  • JAVA中四种访问权限 private<default<protected<public,如果子去重写父的方法,方法的权限默认是和父一样的,但也可以改,但只能加大权限,不能缩小权限,比如父是protected,重写时可以改成public,但如果是public的,重写只能是public
  • 滴滴租车代码,应该算是比较简便了的(有每一步的说明),希望对你们有帮助

    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是租的天数

    }

      }


    }


  • 继承加多态就能解决 一开始想着加个pickup接口完成 走进了死胡同,

    借鉴了下其他人的代码总算是实现了

    public abstract class Car {

    private String carName;//汽车名称

    private int rent;//租金

    private int person;//人数

    private int ton;//载重

    public String getCarName() {

    return carName;

    }

    public void setCarName(String carName) {

    this.carName = carName;

    }

    public int getRent() {

    return rent;

    }

    public void setRent(int rent) {

    this.rent = rent;

    }

    public int getPerson() {

    return person;

    }

    public void setPerson(int person) {

    this.person = person;

    }

    public int getTon() {

    return ton;

    }

    public void setTon(int ton) {

    this.ton = ton;

    }

    }

    public class PassengerCar extends Car {


    public  PassengerCar(String carName,int rent,int person,int ton) {

    this.setCarName(carName);

    this.setRent(rent);

    this.setPerson(person);

    this.setTon(ton);

    }


    @Override

    public String toString() {

    return this.getCarName()+"\t"+this.getRent()+"元/天 载人:"+this.getPerson()+"\t载货:"+this.getTon()+"t";

    }

    }

    public class Truck extends Car {

    public  Truck(String carName,int rent,int person,int ton) {

    this.setCarName(carName);

    this.setRent(rent);

    this.setPerson(person);

    this.setTon(ton);

    }


    @Override

    public String toString() {

    return this.getCarName()+"\t"+this.getRent()+"元/天 载人:"+this.getPerson()+"\t载货:"+this.getTon()+"t";

    }

    }

    public class Pickup extends Car {

    public  Pickup(String carName,int rent,int person,int ton) {

    this.setCarName(carName);

    this.setRent(rent);

    this.setPerson(person);

    this.setTon(ton);

    }


    @Override

    public String toString() {

    return this.getCarName()+"\t"+this.getRent()+"元/天 载人:"+this.getPerson()+"\t载货:"+this.getTon()+"t";

    }

    }

    import java.util.Scanner;

    public class dada {


    public static void main(String[] args) {

    // TODO Auto-generated method stub

    Car[] cars= {

    new PassengerCar("奥迪A4",500,4,0),

    new PassengerCar("马自达6",400,4,0),

    new Pickup("皮卡雪6",450,4,2),

    new PassengerCar("金龙",800,20,0),

    new Truck("松花江",400,0,4),

    new Truck("依维柯",1000,0,20)

    };

    System.out.println("欢迎使用达达租车系统!\n您是否要租车:yes/no");

    Scanner input=new Scanner(System.in);

    String decide=input.next();

    if("yes".equals(decide)) {

    System.out.println("您可租车的类型及其价目表:\n序号\t汽车名称   租金\t容量 ");

    for(int i=0;i<cars.length;i++) {

    System.out.println((i+1)+"\t"+cars[i]);

    }

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

    int num=input.nextInt();

    int serial;

    Car[] newCar=new Car[num];

    for(int i=0;num>0;num--,i++) {

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

    serial=input.nextInt();

    newCar[i]=cars[serial-1];

    }

    System.out.println("请输入租车天数:");

    int day=input.nextInt();

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

    System.out.println("***可载人的车有:");

    int totalPerson = 0;

    int totalTon = 0;

    for(int j=0;j<newCar.length;j++) {

    if(newCar[j].getPerson()>0) {

    System.out.println(newCar[j].getCarName()+"\t");

    totalPerson+=newCar[j].getPerson();

    }

    }

    System.out.println("**载货的车有:");

    for(int j=0;j<newCar.length;j++) {

    if(newCar[j].getTon()>0) {

    System.out.println(newCar[j].getCarName()+"\t");

    totalTon+=newCar[j].getTon();

    }

    }

    System.out.println("***租金总价格:");

    int totalRent=0;

    for(int k=0;k<newCar.length;k++) {

    totalRent+=newCar[k].getRent();

    }

    System.out.println(totalRent*day);

    }

    }

    }



  • HelloWorld.nane和HelloWorld.this.name区别在于, 第一个语句是非法的,想要这样表述,必须对类进行实例化然后再访问它的成员变量:HelloWorld hello=new HelloWorld();hello.name 而第二个语句恰恰就是实现这样的功能,这样就能体现this的作用了
  • 多态的应用:用父类数组存储多个子类对象 父类[] 引用名={new 子类1(),new子类2()......new 子类n()}
  • Dog dog = new Dog(); Animal dog = new Dog();都可以,但是 Dog dog = new Animal();就不可以了,体现了继承的单向性。
  • 继承时候,会纠结父类到底是使用class、abstract class还是interface: 普通class:当父类的方法具有通用性,子类很少重写的情况下,使用普通的class作为父类,这样逻辑就保留在父类,供子类调运即可。 抽象类abstract class:当父类存在部分方法必须在子类进行重写,父类不需要初始化方法逻辑的时候,使用抽象类 接口interface:当针对一批类,制定一套标准和规范的时候,使用接口,接口只定义,不实现。具体的实现全部在子类进行重写。
  • 访问修饰符:用于修饰属性和方法的访问范围。 访问修饰符的总结: private(私有):本类可访问。 default(默认):本类、同包可访问。 protected(保护):本类、同包、子类可访问。 public(公开):本类、同包、子类、其他可访问。
  • 静态初始化块最先执行且只执行一次,然后普通初始化块,然后构造方法
  • 静态方法是属于类的,内存必须为它分配内存空间,这个空间一直由静态方法占用,内存管理器不会由于静态方法没有被调用而将静态方法的存储空间收回,这样如果将所有的方法都声明为静态方法,就会占用大量的内存空间,最后是系统变慢。而普通的成员方法是由对象调用的,内存并不会一直为起分配内存,只有调用的时候才为其分配存储空间,而当其没有被调用时,存储空间就会被内存管理其收回,释放没有用的空间,提高的系统的运行速率!
  • 1、继承语法规则:class 子类 extends 父类{} 2、子类在方法重写时,优先调用子类方法,要注意返回值类型、方法名、参数类型及个数都要与父类继承的方法相同 3、继承的初始化要先父类再子类,同一个类中,先执行属性的初始话,再执行构造方法的初始化。 4、fina修饰后,变量不能被修改,方法不能被覆盖,属性不能被隐式的初始化(类的初始化属性必须有值),或在构造方法中赋值(但只能选其一) 5、final修饰变量时,该变量的值只能赋值一次,即变为常量 6、super在对象内部使用,可以代表父类对象,访问父类的属性:super.属性,访问父类的方法:super.方法()<br> 7、super的应用须知 a、子类的构造过程中必须调用父类的构造方法,如果子类的构造方法中没有调用父类的构造方法,则系统默认调用父类无参的构造方法。 b、如果要显示调用构造方法,必须在子类的构造方法的第一行 c、如果子类的构造方法中既没有显示调用父类的构造方法,而父类又没有无参的构造方法,则编译出错 8、toString()方法返回对象的哈希码,可以通过重写toString()方法表示出对象的属性 9、equals()方法用来比较对象的引用值是否相同,在比较两个对象的值是否相同时,需要重写
  • Scanner input = new Scanner(System.in); System.out.println("欢迎使用达达租车系统:"); System.out.println("请问你是否要租车:y/n"); String n =input.next(); Car car[] = { new PassengerCar("奥迪A4", 500, 4), new PassengerCar("马自达6", 400, 4), new PickupCar("皮雪卡6", 450, 4, 2), new PassengerCar("金龙", 800, 20), new Truck("松花江", 400, 4), new Truck("依维柯", 1000, 20) }; if("y".equals(n)){ System.out.println("您可租车的类型及价格目录表:"); System.out.println("序号" + "\t" + "汽车名称" + "\t" + "租金(元/天)" + "\t" + "容量"); for (int i = 0; i < car.length; i++) {//显示可租借的车辆 System.out.println(" " + (i+1) + "\t" + car[i]); } System.out.print("请输入您要租借的汽车数量:"); int m = input.nextInt(); int sum = 0; for (int i = 1; i <= m; i++) { System.out.print("请输入第"+ i +"辆车的序号:"); int k = input.nextInt(); sum = sum + car[k-1].carMoney; } System.out.print("请输入租车天数:"); int t = input.nextInt(); sum = sum * t ; System.out.println("您的账单为:" + sum); }
  • 封装就好比生活中的抽奖箱,如果没有抽奖箱的存在,所有的抽奖号码球都在地上摆着的话,用户就会加以挑选和改动,不能实现抽奖的目的。加了封装就是把所有的号码球都装进了这个抽奖箱,然后给用户一个规定,必须通过入口去取得号码球,而且一次只能取一个。这样一来用户便不能破换抽奖流程,从而达到抽奖的目的。
  • 在类的声明中,可以包含多个初始化块,当创建类的实例时,就会依次执行这些代码块。如果使用 static 修饰初始化块,就称为静态初始化块。<br> 需要特别注意:静态初始化块只在类加载时执行,且只会执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量。<br> 创建对象的时候就会加载类,就会出现任务结果的前三行。 <br> 程序运行时静态初始化块最先被执行,然后执行普通初始化块,最后才执行构造方法。由于静态初始化块只在类加载时执行一次,所以当再次创建对象 hello2 时并未执行静态初始化块。

举报

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