这个问题牵扯到了修饰符定义访问权限的问题

在Java编译中不同的修饰符会定义不同的访问权限

如果修饰符是public就表示是公开的访问权限，表示这个变量可以在任何地方被调用。

private是另一个修饰符,表示的是私有的访问权限，表示这个变量只能在定义变量的这个类中使用。

instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

equals（)方法

比较的是对象的引用是否指向同一块内存地址

super的应用

如果子类构造方法中既没有显示父类的构造方法，二父类有没有无参的构造方法，则编译出错

方法的重写

语法规则：

a.返回值类型

b.方法名

c.参数类型及个数

都要与父类继承的方法相同，才叫方法的重写

package com.imooc;

public class SCar {

public int number;

public String name;

public int money;

SCar(int number,String name,int money){

this.number=number;

this.name=name;

this.money=money;

}

}

package com.imooc;

public class Car extends SCar {

public int person;

Car(int number,String name,int money,int person){

super(number, name, money);

this.person=person;

}

@Override

public String toString() {

return number + "\t" + name + "\t" + money + "元/天" +"\t" + "载人：" + person + "人";

}

}

package com.imooc;

public class Pickup extends Car {

int goods;

Pickup(int number, String name, int money, int person, int goods) {

super(number, name, money, person);

this.goods = goods;

}

@Override

public String toString() {

return number + "\t" + name + "\t" + money + "元/天" + "\t" + "载人：" + person + "人," + "载货：" + goods + "吨";

}

}

package com.imooc;

public class Truck extends SCar {

public int goods;

Truck(int number,String name,int money,int goods){

super(number,name,money);

this.goods=goods;

}

@Override

public String toString() {

return number + "\t" + name + "\t" + money + "元/天" + "\t" + "载货：" + goods + "吨";

}

}

package com.imooc;

import java.util.Scanner;

public class Initial {

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.println("欢迎使用达达租车系统：");

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

Scanner input1=new Scanner(System.in);

int sc=input1.nextInt();

if(sc==0){

input1.close();

return;

}

if(sc==1){

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

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

Car c1=new Car(1,"奥迪A4",500,4);

//System.out.println(c1);

Car c2=new Car(2,"马自达6",400,4);

//System.out.println(c2);

Pickup c3=new Pickup(3,"皮卡雪6",450,4,2);

//System.out.println(c3);

Car c4=new Car(4,"金龙",800,20);

//System.out.println(c4);

Truck c5=new Truck(5,"松花江",400,4);

//System.out.println(c5);

Truck c6=new Truck(6,"依维柯",1000,20);

//System.out.println(c6);

/* SCar[] sc1 = {new Car(1,"奥迪A4",500,4),new Car(2,"马自达6",400,4),new Pickup(3,"皮卡雪6",450,4,2),

new Car(4,"金龙",800,20),new Truck(5,"松花江",400,4), new Truck(6,"依维柯",1000,20)

};

for(SCar sc2 : sc1){

System.out.println(sc1);

}*/

SCar[] sc1 = {c1,c2,c3,c4,c5,c6};

for(SCar sc2 : sc1){

System.out.println(sc2);

}

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

Scanner input2=new Scanner(System.in);

int zongshu = input2.nextInt();

int[] xuhao = new int[zongshu];

for(int i=0;i<zongshu;i++){

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

Scanner input3 = new Scanner(System.in);

int no = input3.nextInt();

xuhao[i] = no;

}

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

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

int rent1=0,rent2=0,rent3=0,rent4=0,rent5=0,rent6=0,p1=0,p2=0,p3=0,p4=0,g1=0,g2=0,g3=0;

int rentall=0;

int pall=0;

int gall=0;

//载人车

for(int i=0;i<zongshu;i++){

if(xuhao[i]==1){

System.out.print(c1.name + " ");

rent1 = c1.money;

p1 = c1.person;

}

if(xuhao[i]==2){

System.out.print(c2.name + " ");

rent2 = c2.money;

p2 = c2.person;

}

if(xuhao[i]==3){

System.out.print(c3.name + " ");

rent3 = c3.money;

p3 = c3.person;

}

if(xuhao[i]==4){

System.out.print(c4.name + " ");

rent4 = c4.money;

p4 = c4.person;

}

}

pall = p1+p2+p3+p4;

System.out.println("共载人：" + pall);

//载物车

System.out.println("***可载物的车有：");

for(int i=0;i<zongshu;i++){

if(xuhao[i]==3){

System.out.print(c3.name + " ");

g1 = c3.goods;

}

if(xuhao[i]==5){

System.out.print(c5.name + " ");

rent5 = c5.money;

g2 = c5.goods;

}

if(xuhao[i]==6){

System.out.print(c3.name + " ");

rent6 = c6.money;

g3 = c6.goods;

}

}

gall = g1+g2+g3;

System.out.println("共载物：" + gall);

rentall=rent1+rent2+rent3+rent4+rent5+rent6;

System.out.println("***租车总价格：" + rentall + "元");

}

else{

System.out.println("感谢使用本系统！");

}

}

}

定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

包必须放在Java源程序的第一行

包名间用“.”号隔开

包的作用：

管理Java文件

解决同名文件的冲突

我如果把HelloWorld的构造方法改成void，创建对象的时候就不会调用了，必须得单独调用方法，为什么？

public class HelloWorld {

int num1;

int num2;

static int num3;

public void HelloWorld() {

num1 = 91;

System.out.println("通过构造方法为num1变量赋值");

}

{

num2 = 74;

System.out.println("通过初始化块方式为num2变量赋值");

}

static {

num3 = 100;

System.out.println("通过静态初始化块方式为num3变量赋值");

}

public static void main(String[] args) {

HelloWorld hello = new HelloWorld();

//hello.HelloWorld();

System.out.println("num1:"+hello.num1);

System.out.println("num2:"+hello.num2);

System.out.println("num3:"+num3);

HelloWorld hello2 = new HelloWorld();

//hello2.HelloWorld();

}

}

输出结果：

通过静态初始化块方式为num3变量赋值

通过初始化块方式为num2变量赋值

num1:0

num2:74

num3:100

通过初始化块方式为num2变量赋值

1. 类——模子，确定对象将会由的特征和方法。

2. 类——对象的类型

3. 具有相同属性和方法的一组对象的集合。

4. 属性——对象具有的特征

5. 方法——对象执行的操作

6. 类——抽象的存在——模板

7. 对象——具体实体，真正买到的客观存在的事物。
   

super关键字：再对象的内部使用，可以代表父类对象。

1、访问父类的属性：super.age

2、访问父类的方法：super.eat()

super的应用：

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

2、如果显示的调用构造方法，必须在子类的构造方法的第一行。

3、如果子类构造方法中既没有显示调用父类的构造方法，而父类又没有无参的构造方法，则便宜出错。