java中的包

    1、包的作用：

        a、管理java文件

        b、解决同名文件冲突

    2、定义包：package  包名

        a、必须放在java源程序的第一行

        b、包名之间可以用" ."号隔开   com.imooc.MyClass

    3、系统中的包

        a、java.(功能).(类)

        b、java.lang.(类)  包含java语言基础的类

        c、java.util.(类)  包含java语言中各种工具类

        d、java.io.(类)  包含输入、输出相关功能的类

    4、包的使用

        a、可以通过import关键字，在某个文件使用其他文件中的类

        b、包的命名规范是全小写字母

        c、可以加载某个包下的所以文件，也可以具体包下的所有文件

       

成员内部类访问外部类的私有变量：类名.this.变量名

静态内部类访问外部类的私有变量：类名.变量名

面向对象

对象就是一个具体的事物， 从客观让类是一种不存在的东西，只是用来描述确定对象将会拥有的特征（属性）和行为（方法）；如生活中的手机就是一个类（从某种角度讲），一说到手机我们就会想到，屏幕尺寸、CPU、内存这些特征（属性），以及打电话、发短信的行为（方法），而真的的对象就是具体的事物，如手机中的小米、三星、华为等具体的东西；最后再说一句，类是对象的类型，是具有相同属性和方法的一组对象的集合。

//父类

public  class Car(){

private int id;

private String name;

private int price;

 

public int getid{

return id;

}

public void setid{

this.id =id;

}

public int getname{

return name;

}

public void setname{

this.name =name;

}

public int getprice{

return price

}

public void setprice{

this.price =price;

}

}

//客车子类

public kecar extends Car{

private int keliang;

    public kecar(int id,String name,int price,int keliang){

   this.setid(id);

        this.setname(name);

        this.setprice(price);

        this.keliang=keliang; 

}

public int getkeliang{

   return keliang;

}

    public void setkeliang{

   this.keliang =keliang;

}   

}

//皮卡子类

public pika extends Car{

  private double huoliang;

  private int keliang;

  

  public pika(int id,String name,int price,int keliang,double huoliang,int keliang){

this.setid(id);

    this.setname(name);

    this.setprice(price);

    this.setkeliang(keliang);

    this.huoliang=huoliang;

    this.keliang=keliang;

  }

  public double gethuoliang{

return huoliang;

  }

  public void sethuoliang{

this.huoliang=huoliang;

  }

  public int getkeliang{

return keliang;

}

  public void setkeliang{

this.keliang =keliang;

}

}

//货车子类

public huocar extends Car{

private double huoliang;

    public huocar(int id,String name,int price,int keliang,double huoliang){

   this.setid(id);

        this.setname(name);

        this.setprice(price);

        this.setkeliang(keliang);

   this.huoliang=huoliang;

}

    public double gethuoliang{

   return huoliang;

  }

    public void sethuoliang{

   this.huoliang=huoliang;

  }

}

//测试类

public class Test{

public static void main(String[] args){

  System.out.println("欢迎使用大大打车系统")；

  System.out.println("是否租车：1.是 其他键退出")

  Test test=new Test();

  while(test.test1()){

System.out.println("你可以选择的车型和价目表");

         System.out.println("------------------------");

         Car[] cars={new kecar(1,"奥迪A8",800,4),

            new kecar(2,"兰博基尼",3000,4),

new pika(3,"福特猛禽",1300,4,2),

new huocar(4,"斯柯达",500,4),

new huocar(5,"依维柯",1000,20)

};

System.out.println("编号"+" "+"\t"+"车型"+"  "+"\t"+"租金"+" "+"\t"+"容量");

        //foreach的格式:for(元素类型T 每次循环元素的名称O : 循环对象)

for(Car car:cars){

          if(car.getClass().equals(kecar.class)){

System.out.println(car.getid()+"\t"+"\t"+car.getname()+"\t"+"\t"+car.getprice()+"/天"

+"\t"+"载客"+((kecar)car).getkeliang()+"/人"); //((kecar)car)强制转换

 }

 if(car.getClass().equals(pika.class)){

System.out.println(car.getid()+"\t"+"\t"+car.getname()+"\t"+"\t"+car.getprice()+"/天"

+"\t"+"载客"+((pika)car).getkeliang()+"/人"+" "+"载货"+((pika)car).gethuoliang()+"/吨");

 }

          if(car.getClass().equals(huocar.class)){

System.out.println(car.getid()+"\t"+"\t"+car.getname()+"\t"+"\t"+car.getprice()+"/天"

+"\t"+"载货"+((huocar)car).gethuoliang()+"/吨"); 

  }

  }

        System.out.println("------------");

        System.out.println("请输入你要租车的数量")；

//新建一个扫描器（创建一个Scanner，控制台会一直等待输入，直到敲回车键结束，把所输入的内容传给Scanner，作为扫描对象）

        Scanner c =new Scanner(System.in);

//c.nextInt()是扫描到输入的值

int carnum= c.nextInt();//用于接收租车数量

List<Car> carlist=new ArrayList<>();//调用集合框架list用于存储客户租车清单

int add=0;//扩展列表容量

List<Car> carlistkecar=new ArrayList<>();//用于存储载人的车辆

        List<Car> carlisthuocar=new ArrayList<>();//用于存储载货的车辆

        int passengerCar=0;//载人数

        int Carhuo=0;//载货数

        int Carprice=0;//总资金

        

for(i=0;i<=carnum;i++){

   System.out.println("请输入你要租第"+(i+1)+"号车");

int num=c.nextInt();

carlist.add(cars[num-1]);

System.out.println("成功添加"+carlist.getadd().getname());

if(cars[num-1].getClass().equals(kecar.class)){

passengerCar+=((kecar)carlist.getadd().getkeliang());

Carprice+=((kecar)carlist.getadd().getprice());

carlistkecar.add(carlist.getadd());

}

if(cars[num-1].getClass().equals(pika.class)){

passengerCar+=((pika)carlist.getadd().getkeliang());

Carhuo+=((pika)carlist.getadd().gethuoliang());

Carprice+=((pika)carlist.getadd().getprice());

carlistkecar.add(carlist.getadd());

carlisthuocar.add(carlist.getadd());

}

if(cars[num-1].getClass().equals(huocar.class)){

Carhuo+=((huocar)carlist.getadd().gethuoliang());

Carprice+=((huocar)carlist.getadd().getprice());

carlisthuocar.add(carlist.getadd());

}

add++;

}

System.out.println("请输入你要租车的天数")；

Scanner d=new Scanner(System.in);

int carDay=d.nextInt();

Carprice=Carprice*carDay;

System.out.println("租车完成"+"\n"+"开始统计数据");

System.out.println("你共租了"+carnum+"辆车：");

for(Car car:carlist){

System.out.print(car.getname());

}

System.out.println();//直接换行或为了排版和打印特殊图案

System.out.println("共租"+carDay+"天");

System.out.println("可载"+passengerCar+"人");

System.out.println("可载"+Carhuo+"吨");

System.out.println("共需租金"+Carprice+"元");

System.out.println("请付钱")

System.out.println("--------");

Scanner q=new Scanner(System.in);

if(Carprice!=q.nextInt()){

System.out.println("付钱金额错误，请重新付钱");

}else{

System.out.println("--------------");

System.out.println("交易成功");

}

System.out.println();

System.out.println("----感谢您的使用----")；

System.out.println("继续租车请按1，退出任意键")；

  }

       System.out.println("----欢迎你再次使用，再见------");

}

//捕获异常

public boolean test1{

try{

Scanner t=new Scanner(System.in);

if(t.nextInt==1){

return true;

}else{

return false;

}

   }catch(Exception e1){

return false;

}

}

}

   

看到 一段不错的 解释：  - **当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口**。



e.g. 抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类,他们的抽象类是人。说明，他们都是人。



人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.



所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

面向对象知识点： 类 创建对象 继承关系（子类可以继承父类的属性和方法） 方法重写（子类有独特的方法） 多态（父类引用指向对象） 代码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(); } }

静态变量的访问可以不创建对象， 直接用 类名.静态变量 也可以创建对象用 “对象名.静态变量” 访问静态变量。 还可以通过改变 对象名.静态变量 来改变静态变量的值。 问：可以通过 “类名.静态变量” 访问静态变量 如：HelloWorld.className；也可以通过 “对象名.静态变量” 访问静态变量。但是，什么也不加，直接className也可以呀？是因为有什么弊端吗？ 答：静态变量是可以直接引用的，不过是不安全的。在访问静态变量的时候首选是类名.静态变量的方式，这不仅是因为它强调了变量的static的结构，而且在某些情况下它还为编译器进行优化提供了更好的机会 你看完下一节内容就明白了，因为我们的main（）前也有一个static关键字，这表明mian（）是一个静态方法，而静态方法是可以直接访问静态变量的。 你所谓的直接className是在一个类里面才行的通，出了这个类就报错。 1.静态成员变量是属于整个类的全局变量，它不单属于某一个对象；普通成员变量是属于类中的对象，它不能被所有对象共享。 2.静态成员变量必须在全局进行定义，而由于普通成员变量在创建一个对象的时候可以对它进行初始化，因此就不需要单独对它进行定义，只要声明即可。 3.静态成员变量在没有对象之前就存在。 1·、static应用范围：可用于内部类、方法和变量。 2、标记一个方法为static，意味着这个方法，被所在类的所有实例公用，在类装载时被首先执行，执行一次即被所有该类的实例共享，同时意味着： A、static方法内部不能引用非static变量。 B、static方法不能被子类重写为非static方法。 C、父类的非static方法不能被子类重写为static方法。 D、static代码块可以用static {}来完成，在类被第一次装载时执行初始化，先于静态方法和其他方法的执行。 3、标记一个变量为static，则该变量在内存中有不变的位置，相当于全局变量，所有类的实例都访问同一个存储变量区域。对其修改对于所有类的实例来说都是可见和一致的。 1、类的静态成员变量不是属于任何一个特定的对象，而是属于该类，当系统第一次使用该类时就会为其分配内存空间直到该类被卸载才会进行资源回收。 2、静态成员变量可以用类直接访问、也可以用对象访问（对象访问也可以更改其值）推荐用类访问。

简单举例好比说，我现在有一部魅族MX5手机，这部手机就是一个对象。 这部手机是4.5英寸的，电池容量是3000毫安的，八核CPU的，双卡双待的，带有魅族自带系统的，运行内存是3gb的，内存容量是32gb的。这些都是属性或特征。 这部手机可以用来打电话、玩游戏、发微信、拍照、发短信、看视频这些都是方法或行为。 通过类，我可以对这部手机的特征属性和行为方法进行描述。 然后，当有人问我这部手机的有什么特征属性或行为方法的时候，我就需要调用这部手机的这些属性或方法。或者由人问我关于属性或方法的某个问题，我就调用其中的一个属性或方法。告诉他我这部手机有什么属性或方法。 我现在有多部手机，我可以通过创建一个外部类手机，然后创建多个内部类的多个品牌的手机，然后通过创建相应的对象来进行调用。

1、创建两个接口（载客接口A-载客量）、（载货接口B-载货量），载客和货接口C extend 载客接口A，载货接口B（载客量、载货量），一个抽象父类Car（车型、单价-->元/天）； 2、实现-卡车类 extend 父类Car implement 载货接口B； 实现-客车类 extend 父类Car implement 载客接口A； 实现-皮卡类 extend 父类Car implement 载客和货接口C；

我的构造函数小结： 1、是什么——构造函数（构造方法）是一个和类同名的函数（方法） 2、为什么——使用构造方法or自定义构造方法后，可以很方便地对类进行实例化 3、怎么办——构造方法和一般方法的不同之处在于其没有返回值。 语法是public 构造方法名(参数列表){ } 【注1】可以有参数列表，也可以没有参数列表 【注2】不管定义几个构造函数，所有的构造函数名必须和类同名，这就涉及到Java中 的重载 【注3】如果编程者没有自定义一个构造函数，则程序运行时会自动生成一个无参的构造函数。而一旦编程者自定义过构造函数，则程序不会再自动生成无参的构造函数。 4、怎么样——更加方便对类进行实例化 Public class Telephone{ Float screen; Float cpu; Float mem; Void show(){System.out.println(“屏幕：”+screen+”,CPU：”+cpu+”，内存：”+mem);} } 若没有构造函数，则需要重新在main中逐个给screen、cpu、mem赋值再引用show 但若我们自定义了一个构造函数， Public class Telephone(float newSceen,float newCpu,float newMem){ screen=newScreen; cpu=newCpu; mem=newMem; } 则我们在实例化的时候可以直接这样做 Telephone phone1=new Telephone(1.1f,2.2f,3.3f); Telephone phone2=new Telephone(4.4f,5.5f,6.6f); Telephone phone3=new Telephone(7.7f,8.8f,9.9f); 当要实例化多个对象时，先自定义一个构造函数无疑是个明智的选择。

定义类的时候，名字的首字母要大写

if(object instanceof class) 当满足下列条件，if语句中的表达式为true: 1.class所表示的类就是object实际所指向的类； 2.class所表示的类是object实际所指向类的父类及其祖先（即父类的父类，父类的父类的父类，。。。）。 注意：这里object实际所指向的类并不一定是object声明时所使用的对象类型。如课程中的代码： Dog dog = new Dog(); Animal animal = dog; animal实际所指向的类已经自动转换为Dog，并不是声明的Animal。

package com.imooc; public class Test { public static void main(String[] args) { Traffic_tools obj1 = new Traffic_tools(); Traffic_tools obj2 = new Bus(); Traffic_tools obj3 = new Ship(); Traffic_tools obj4 = new Airplane(); Traffic_tools obj5 = new Bike(); Traffic_tools obj6 = new Train(); obj1.use(); obj2.use(); obj3.use(); obj4.use(); obj5.use(); obj6.use(); } } package com.imooc; public class Traffic_tools { public void use(){ System.out.println("交通工具"); } } package com.imooc; public class Bus extends Traffic_tools { public void use(){ System.out.println("大巴能在陆地运输40个人"); } } package com.imooc; public class Ship extends Traffic_tools { public void use(){ System.out.println("轮船能在海里运输200个人"); } } package com.imooc; public class Airplane extends Traffic_tools { public void use(){ System.out.println("飞机能在空中运输600人"); } } ...... ......

package com.imooc; public class Text { public static void main(String[] args) { Telephone phone1 = new Telephone(); phone1.screen = 5.5f; phone1.cpu = 1.4f; phone1.mum = 2.0f; Telephone phone2 = new Telephone(); phone2.screen = 5.5f; phone2.cpu = 1.4f; phone2.mum = 2.0f; if(phone1.equals(phone2)){ System.out.println("两个对象是相同的"); }else{ System.out.println("两个对象是不同的"); } } } package com.imooc; public class Telephone { float screen; float cpu; float mum; @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Telephone other = (Telephone) obj; if (Float.floatToIntBits(cpu) != Float.floatToIntBits(other.cpu)) return false; if (Float.floatToIntBits(mum) != Float.floatToIntBits(other.mum)) return false; if (Float.floatToIntBits(screen) != Float.floatToIntBits(other.screen)) return false; return true; } }

继承的初始化顺序： 1.初始化父类再初始化子类 2.先执行初始化对象中属性，再执行构造方法中的初始化 3.代码演示： （1） 父类构造方法先执行 再执行子类构造方法 最后执行子类中的某个方法 （2）父类对象-->父类属性初始化-->父类构造方法-->子类对象--> 子类属性初始化-->子类构造方法