在普通成员方法中，则可以直接访问同类的非静态变量和静态变量

创建对象，实际上是执行构造方法

1.作用域不同

    局部变量的作用域仅限于定义它的方法

    成员变量的作用域在整个类内部都是可见的

2.初始值不同

    Java会给成员变量一个初始值

    Java不会给局部变量赋予初始值

3.

    在同一个方法中，不允许有同名局部变量；

    在不同的方法中，可以有同名局部变量

4.两类变量同名时，局部变量具有更高的优先级

float型变量赋值时需加f，否则默认浮点数是double型

instanceof 运算符  解决引用对象的类型转换问题 

它的作用是用来判断，instanceof 左边对象是否为instanceof 右边类的实例，返回一个boolean类型值。还可以用来判断子父类的所属关系。

 

if(an instanceof Dog) {    //instanceof 运算符  判断解决引用对象的类型转换问题 ，

Dog dog = (Dog)an;

}else {

System.out.println("无法进行类型转换")

}

Animal an = new Animal();

Animal dog = new Dog();   //引用多态特性第一条：父类的引用可以指向子类对象

Dog dog = new Animal();   //  但是反过来不行,错误

an.eat();                 //方法多态特性：调用的时Animal的eat方法

dog.eat();                //调用的是Dog的eat方法（继承父类的或者重写的eat方法）

dog.watchDoor();          //不能调用子类特有的方法

super关键字：

       在对象内部使用，可以代表父类对象

1、应用范围：

①访问父类属性

例如：super.age

2、访问父类的方法

例如：super.eat( )

注意：子类属性或方法均可直接引用

代码如下：

public void method(){

    super.eat();//调用父类方法eat()

    eat();//调用子类方法()

    System.out.println("父类对象age的值为："+super.age);//输出父类对象age的值10

    System.out.println("子类对象age的值为："+age);//输出子类对象age的值30

    }

2、super与构造方法的关系

子类的构造过程中必须调用父类的构造方法

1、如果子类的构造方法中显示（写了super( )代码）调用父类的构造方法，则super()代码必须放在子类构造方法中的第一行；

2、如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法；

3、如果子类的构造方法中既没有显示调用父类的构造方法，而父类也没有无参的构造方法，则编译出错！

代码如下：

public Dog(){

//super();子类构造方法首先隐式调用父类的构造方法super()并创建父类对象，所以此处写不写super()都一样

System.out.println("Dog类构造方法被执行了！");

//age=40;

}

继承：

1. 继承是类与类的一种关系，“is a "

   子类/派生类

   父类/基类

2. java中的继承是单继承（一个子类只有一个父类；一个父类可以有多个子类）

3. 继承的好处：

     子类拥有父类的所有属性和方法（非private修饰的属性及方法）

     实现代码的复用

4. 语法：

       修饰符  class 子类 extends 父类{

}

由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

静态内部类是 static 修饰的内部类，这种内部类的特点是： 1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员 3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

成员内部类的使用方法： 1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等 2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a 3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

继承加多态就能解决 一开始想着加个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);

}

}

}

内部类的方法可以直接访问外部类的所有数据，包括私有的数据

构造方法的方法名必须与类名一样。

构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。 

构造方法不能作用是完成对象的初始化工作，他能够把定义对象时的参数传递给对象的域。

 构造方法可以重载，以参数的个数，类型，或排序顺序区分与普通的方法重载是一样的。

new对象时，都是用构造方法进行实例化的；

 例如；Test test = new Test（"a"）；

  //Test（"a"）；其中这个就是构造函数，“a”为构造方法的形参；

语法格式：  public 构造方法名（）{

                     //初始化代码

        }

匿名内部类的语法格式 ，截图所示 接口(1.常量和关键方法组成，规范类的作用) interface关键字 2.语法 abstract系统隐藏自定义 [修饰符] interface 接口名[extend 父接口1，父2] { 常量 抽象方法 } 3.接口定义 常量：public static final修饰符，系统自动 方法：public abstract修饰符 4.使用接口(implements关键字) *继承父类实现接口的语法为： [修饰符]class 类名 extends 父类 implements 接口1… { }