1.面向对象与面向过程的区别
面向过程：
优点:比面向过程性能好，因为面向对象调用类的时候需要实例化，比较消耗资源，像单片机,嵌入式等等一般采用的是面向过程开发，因为比较消耗资源
缺点:没有面向对象易于维护，扩展，复用
面向对象:
优点:易于维护，易于复用，易于扩展，可以降低系统的耦合度，是系统更加的灵活
缺点:比较消耗资源，性能低于面向过程
2.java语言的特点
1.简单易学
2.面向对象(继承,分装，多态)
3.与平台无关(运行在jvm当中)
4.安全性
5.可靠性
6.支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）；
7.支持网络编程并且很方便（ Java 语言诞生本身就是为简化网络编程设计的，因此 Java 语言不仅支持网络编程而且很方便）；
8.编译与解释并存
3.jdk,jre,jvm三者之间的区别与联系
JDK:java开发工具包，包括jre与其他的一些供开发者使用的包。
JRE：java运行是环境，普通的用户只需要安装JRE来运行程序就可以了，程序员必须安装JDK来调试，开发，运行java程序。
jvm:java虚拟机，当我们运行一个程序的时候，jvm负责将字节码文件(.class)转换为特定的机器码文件，jvm提供了内存管理/垃圾回收/安全机制，jvm与硬件与操作系统无关,这中与平台无关的性能，正是java可以一次编译处处运行的原因
区别与联系:
JDK用于开发,JRE用于运行java程序
jdk与JRE当中都含有JVM
JVM是java编程的核心，并且拥有平台无关性
4.什么是字节码，字节码的最大好处是什么？
在java当中，供JVM理解的代码(.class)叫做字节码，他只面向JVM，不面向任何特点的处理器。
java程序生成.class文件，他只需要面向JVM即可，jvm当中的解释器将.class代码解释为对应机器的机器码，JVM在任何平台都提供给编译程序一个相同的接口，每个个平台的解释器是不同的，但是都实现的JVM是相同的(对任何平台的编译程序都提供了相同的接口)。
JVM将字节码代码交给解释器解释，解释器将代码生成特定机器上的机器码，然后在机器上运行。
字节码的好处:
字节码并不是针对某一特定的机器的，他只是针对JVM的，因此无需再重新编译就可以在不同的计算机上面运行。
5.java与C++的区别
1.都是面向对象语言
2.java不提供指针来访问内存，安全性更高
3.java当中是单继承的，c++当中是多继承的
4.java当中有自动内存管理机制，无需程序员手动释放内存空间
6.java应用程序与小程序的主类有什么不同
一个java应用程序可以有很多个类，但是只能有一个主类，这个主类是包含main()方法的类，而在java小程序当的主类一定是继承自系统类JApplet或者Applet的类，应用程序的主类不一定是public，小程序的主类一定是public。
7.java应用程序与小程序之间的区别
简单来说，应用程序是从主线程(main)启动的,小程序没有main方法，他是镶嵌在浏览器(调用init()线程或者run()来启动)当中运行的。嵌入浏览器这点与flash的小游戏类似。
8.字符串常量与字符常量的区别
在java当中每一种基本数据类型所占的字节大小是固定的，并不像其他大多数编程语言那样随着机器硬件架构的变化而变化，这种锁占存储空间的固定正是java语言比吉他语言更具移植性的原因之一。
注意在进行自动转换的时候；long可以直接转换为float，虽然long是8个字节，float是4个字节，但是浮点数在内存中的32位不是简单地转换为十进制，而是通过公式 V=(-1)^s * M * 2^E 来计算而来，通过这个公式虽然，只有4个字节，但浮点数最大值要比长整型的范围要大。
小数的默认数据类型是double，比如3.21，默认是double类型的，float a=3.21会报错，整数的默认数据类型是int，比如3，默认是int类型的
当所占的字节大小是相同的时候，整数可以转换为小数，小数不能转换为整数
============下面的是正确的==============
long a=3;
float t=a;
double f=a;
============下面的是错误的==============
double d=3.21;
long l=d;
即：long可以转换为float，double，逆向则不可以
9. 构造器 Constructor 是否可被 override
父类的私有属性与构造器并不能被继承，所以Construct不能被重写(override),但是可以被重载(overload)
10.重载与重写的区别
重载(5不同):同一个类当中，方法名必须相同，参数类型可以不同，参数类型的顺序可以不同，参数个数不同，方法返回值与权限修饰符可以不同
重写(2同2小1大):有父子继承关系的类当中,方法名，参数列表必须相同。返回值类型，抛出异常必须要小于等于父类。权限修饰符范围大于等于父类，
如果父类方法访问修饰符为 private 则子类当中就不能叫做重写。
11.面向对象的三大特性
封装:将类的属性私有化，提供一些可以供外界访问的属性set，get方法，如果不想被外界访问，可以不提供set,get方法，但是这样这个类就没有意义了。
继承:使用已经存在的类作为基类建立新类的技术，新类可以在基类的基础上面进行拓展，通过继承可以非常方便的复用以前的代码
关于继承:
子类拥有父类的一切非private修饰方法与属性
子类可以在父类的基础上面进行扩展，可以有自己的方法与属性
多态:子类的实例赋值给父类的引用
Parent p=new Child();
p.test();
引用变量所指向的具体类型（Parent/Child未知）与引用变量所调用的方法(Parent的test方法，还是Child的test方法未知)，只有在运行的时候才知道，在运行时才可以确定
java当中有2中方法可以实现多态：继承父类(重写父类当中的方法)，实现接口(实现接口并重写接口当中的某个方法)。
package com.xd.map;
public class Child extends Parent {
public void test() {
System.out.println("这是子类...");
}
public static void main(String[] args) {
Parent parent=new Parent();
//运行期报错，java.lang.ClassCastException，多态在运行器材可以确定是否可以转换
Child child=(Child)parent;
child.test();
}
}
Exception in thread "main" java.lang.ClassCastException: com.xd.map.Parent cannot be cast to com.xd.map.Child
at com.xd.map.Child.main(Child.java:12)
父类不能强转为子类
Child c=new Parent(); x
Child c1=(Child) new Parent();
========================
Parent p=new Child();
p.test();//这是子类
Parent p=(Parent) new Child();//这是子类
Parent p1=(Parent) new Child();//这是子类
12.String,StringBuffer,StringBuilder的区别与联系
可变性:
String当中使用final修饰符数组 (final char [] value)保存字符串，所以String当中的字符串都是固定的，可以理解为常量，StringBuffer当中也是采用字符数组(char [] value)保存字符串的,但是他不是final修饰的，故他的长度是可以追加的，是可变的，StringBuilder也是一样.二者都继承自AbstractStringBuilder。
安全性:
StringBuffer与StringBuilder都继承自AbstractStringBuilder，AbstractStringBuilder当中提供了一些方法， expandCapacity、append、insert、indexOf 等公共方法，但是StringBuffer对继承的方法进行了重写加锁，所以是线程安全的，StringBuilder没有对继承的方法进行加锁，所以是线程不安全的。
性能
每次对String进行操作都会生成一个新的String对象，然后将指正指向新的String对象，StringBuffer对象每次都是对StringBuffer本身进行操作，在同等情况下，StringBuilder的新能只比StringBuffer高10%--15%，但却要付出安全性为代价。
总结
1.String用来操作少量的数据
2.StringBuffer用来操作大量多线程数据
3.StringBuilder用来操作大量单线程数据
13.自动装箱与自动拆箱
自动装箱:基本数据类型转换为包装类
自动拆箱:包装类自动转换为基本数据类型
14.在静态方法当中不能直接调用非静态的方法与属性
在静态方法当中调用非静态方法只能通过类对象来调用，不能通过类名直接调用
package com.xd.map;
public class Test3 {
int a=10;
public void test() {
System.out.println("=============");
}
public static void main(String[] args) {
Test3 test3=new Test3();
//=============
test3.test();
//10
System.out.println(test3.a);
}
}
15.父类的无参构造器的作用
在java当中初始化的时候默认(未使用super()有参调用)调用的是父类的无参构造器，如果在父类当中定义了一个有参构造器，那么子类当中会报错，因为找不到默认的无参构造器
class Parent {
public Parent(int a) {
System.out.println("这是父类的有参构造器");
}
public void test() {
System.out.println("这是父类....");
}
}
//报错Implicit super constructor Parent() is undefined for default constructor. Must define an explicit constructor
public class Child extends Parent {
public void test() {
System.out.println("这是子类...");
}
}
16.import java与javax有什么不同
在刚开始的时候javax是作为Javax的扩展引入的，后来javax逐渐成为了java API的一部分，但是将javax移入java ApI比较麻烦，会破会掉现有的java API源代码，所以最终决定将javax作为标准java API的一部分，事实上2者没有区别只是名字不一样而已
17.java当中接口与抽象类的区别是什么？
接口默认是public的(不写也默认是public的)
1.接口当中的方法默认都是public的(不写的时候也默认是public)，接口当中的属性默认都是public static final的(不写的时候也默认是public static final,修改会报错)。
2.抽象类和普通的类差别不是很大，最大的差别就是抽象类当中可以有抽象方法，抽象类当中的抽象方法必须要显示的指明，他不像接口一样如果未显示指明会报错
3.接口与抽象类都不可以实例化，但是接口可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。
抽象方法都不能被static,private,synchronized,native修饰
总结
接口，接口当中的方法，接口当中的属性都使用public修饰(无论写不写)
方法:public abstract 修饰(无论写不写)
属性:public static final 修饰(无论写不写)
JDK1.8：
可以在接口当中定义普通方法，普通方法必须使用使用static修饰
static:只能通过接口名调用
interface Test1 {
public abstract void t1();
public static void t2() {
};
}
public class Test1Impl implements Test1 {
@Override
public void t1() {
// TODO Auto-generated method stub
}
public static void main(String[] args) {
//必须要通过接口名调用，不能通过实现类调用
Test1.t2();
}
}
抽象类，
成员变量: 默认default的
成员方法：可以有抽象方法和非抽象方法 ,抽象方法必须要显示的指定
18.成员 变量与局部变量的区别
1.成员变量又叫全局变量，可以被权限修饰符(private ,public 及static)修饰，局部变量从语法形式上是属于方法的，不能被权限修饰符(private ,public 及static)修饰，但是局部变量与成员变量都可以被final修饰。当成员变量被static修饰的时候，成员变量就变成了类变量，类变量是类层次的随着类的加载而加载，普通的常用变量是随着对象的创建而加载的
2.从变量在内存当中的存储形式上看，成员变量是对象的一部分，存储在堆当中，局部变量存储在栈当中。
3.从变量在内存中的生存时间上看，成员变量是对象的一部分，随着对象的创建而创建，局部变量在随着方法的调用完毕之后消失
4.成员变量如果没有被赋初值，则会自动以类型的默认值而赋值(当中使用final修饰的时候必须要赋初值，否则会报错)
局部变量如果不赋初值，就不会自动赋值，如果输出就会报错
public class Test4 {
public static void main(String[] args) {
int a;
System.out.println(a);
}
}
当局部变量使用final修饰的时候，可以不赋初值，只要在后面赋值即可，但是一旦赋值就不可以改变
public class Test4 {
public static void main(String[] args) {
final int a;
a=1;
System.out.println(a);
}
}
19. 创建一个对象用什么运算符？对象实体与对象引用有何不同？
new运算符，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有n个引用指向它（可以用n条绳子系住一个气球）。
20.方法的返回值
当返回值类型为void的时候，可以写成如下的2中形式
package com.xd.map;
public class Test4 {
public void tt(){
return ;
}
public void tt1(){
}
}
21.类的构造方法的特新与左右
类的构造方法主要是用来完成一些初始化的操作
特性：
1.类名与方法名相同
2.没有返回值，不能写成void
3.在new对象的时候自动调用
22.对象的相等与指向他们的引用相等，两者有什么不同？
对象的相等，比的是内存中存放的内容是否相等。而引用相等，比较的是他们指向的内存地址是否相等。
23.== 与 equals(重要)
1.==用来判断2个对象的地址是不是相等，即判断2个对象是不是同一个对象，(基本数据类型判断的是值是否相等，引用类型判断的是地址值是否是相等，是否是同一对象)
2.equals()的作用也是判断2个对象是否相等，但是一般分为如下的2中情况：
(一)：
重写了Object当中的equals()方法，让他用来比较2个对象的值是否相等
(二)：
没有重写equals当中的equals()方法，比较的还是地址，与==相同
public class test1 {
public static void main(String[] args) {
String a = new String("ab"); // a 为一个引用
String b = new String("ab"); // b为另一个引用,对象的内容一样
String aa = "ab"; // 放在常量池中
String bb = "ab"; // 从常量池中查找
if (aa == bb) // true
System.out.println("aa==bb");
if (a == b) // false，非同一对象
System.out.println("a==b");
if (a.equals(b)) // true
System.out.println("aEQb");
if (42 == 42.0) { // true
System.out.println("true");
}
}
}
说明：
String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。
当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。
24.HashCode()与equals()方法
hashCode()的作用是获取哈希码，又叫散列码，他返回的是一个int类型的证整数，这个int值就是这个对象在哈希表当中的索引位置，他的作用是获取对象在哈希表当中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。
哈希表是键值对的方式存储的，可以通过键快速的找到对应的值，（即通过索引快速的找到对应的对象）
为什么要有 hashCode
考虑一种情况，当向集合中插入对象时，如何判别在集合中是否已经存在该对象了？（注意：集合中不允许重复的元素存在）
**也许大多数人都会想到调用equals方法来逐个进行比较，这个方法确实可行**。但是如果集合中已经存在一万条数据或者更多的数据，如果采用equals方法去逐一比较，效率必然是一个问题。此时hashCode方法的作用就体现出来了，当集合要添加新的对象时，先调用这个对象的hashCode方法，得到对应的hashcode值，实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值，如果table中没有该hashcode值，它就可以直接存进去，不用再进行任何比较了；如果存在该hashcode值， 就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址，所以这里存在一个冲突解决的问题，这样一来实际调用equals方法的次数就大大降低了。
hashCode（）与equals（）的相关规定
hashCode值相同并不一定是同一个对象，就好比字典上的第100页上有“书”，“数”，“熟”等，100就是hashCode值，“书”，“数”，“熟”的具体位置就是地址
1.如果2个对象相等，则hashcode值也相同
2.两个对象相等,对两个对象分别调用equals方法都返回true
3.两个对象有相同的hashcode值，它们也不一定是相等的
4.因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖
25.为什么Java中只有值传递？
在程序设计语言当中有2种参数值的传递方式：按值传递：表示方法接收的是调用者提供的值，按引用对象传递：表示方法接收的是调用者提供的变量地址
方法接收的是调用者提供的值
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
swap(num1, num2);
System.out.println("num1 = " + num1);
System.out.println("num2 = " + num2);
}
public static void swap(int a, int b) {
int temp = a;
a = b;
b = temp;
System.out.println("a = " + a);
System.out.println("b = " + b);
}
结果
a = 20
b = 10
num1 = 10
num2 = 20
在swap方法中，a、b的值进行交换，并不会影响到 num1、num2。因为，a、b中的值，只是从 num1、num2 的复制过来的。也就是说，a、b相当于num1、num2 的副本，副本的内容无论怎么修改，都不会影响到原件本身。
而对象引用作为参数就不一样
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
System.out.println(arr[0]);
change(arr);
System.out.println(arr[0]);
}
public static void change(int[] array) {
// 将数组的第一个元素变为0
array[0] = 0;
}
结果：
1
0
array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向的时同一个数组对象。 因此，外部对引用对象的改变会反映到所对应的对象上。
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student s1 = new Student("小张");
Student s2 = new Student("小李");
Test.swap(s1, s2);
System.out.println("s1:" + s1.getName());
System.out.println("s2:" + s2.getName());
}
public static void swap(Student x, Student y) {
Student temp = x;
x = y;
y = temp;
System.out.println("x:" + x.getName());
System.out.println("y:" + y.getName());
}
}
结果:
x:小李
y:小张
s1:小张
s2:小李
26. 简述线程，程序、进程的基本概念。以及他们之间关系是什么？
程序在执行的时候，将会被操作系统载入到内存当中
线程:线程是最小的进程，一个进程可以有许多的线程，同类的多个线程共享同一块内存空间与同一组系统资源，当系统产生一个线程，在各个线程之间切换工作时，负担要比进程小的多(共享同一内存空间，访问同一组系统资源)，所以线程又叫轻量级进程。
程序：含有指令与数据的文件，被存储在磁盘或者其他的存储设备当中，冶金是说程序是静态的代码
进程:程序的一次执行过程，因此进程是动态的，系统运行一个程序即是一个进程从创建(new)，运行到销毁的过程。简单来说，进程是执行当中的程序，他在计算机当中一个指令接着一个指令的执行，同时各个进程都会栈有不同的内存与系统资源，各个进程所占有的东西是独立的。
27.线程有哪些基本的状态？他们是怎么定义的?
1.创建(new):新建一个线程对象
2.可运行(runnable):线程对象创建之后，其他的线程(比如main线程)，调用了该对象的start()方法，该状态的线程位于可运行线程池当中，等待线程调度的选中，获取CPU的使用权(获取时间片)。
3.运行(running):可运行状态的线程，被线程调度选中，获得了CPU的使用权，执行程序代码。
4.阻塞(block):运行当中的线程因为某些原因放弃了CPU的使用权，退出了时间片，暂时停止运行，直到该线程进入可运行状态(runnable)状态，才有 机会再次获得cpu timeslice转到运行(running)状态。
阻塞的情况一般分为3种：
(等待阻塞)：运行当中的线程执行wait()方法，JVM会把线程放入等待队列当中.
(同步阻塞)：运行当中的线程在获取对象的同步锁的时候，该同步锁被其他的线程所占用，JVM会把给线程放入到锁池(lock pool)当中.
(其他阻塞)：运行当中的线程执行sleep(),或者join(),或者发出I/O请求的时候，JVM会将该线程至为阻塞状态，当sleep(),join(),I/O超时或者完毕之后，会重新进入runnable状态。
5.死亡(dead)：当run方法执行完毕，或者main方法执行完毕，或者run方法因为异常执行完毕，此时线程死亡，线程死亡之后不可恢复。
备注： 可以用早起坐地铁来比喻这个过程：
还没起床：sleeping
起床收拾好了，随时可以坐地铁出发：Runnable
等地铁来：Waiting
地铁来了，但要排队上地铁：I/O阻塞
上了地铁，发现暂时没座位：synchronized阻塞
地铁上找到座位：Running
到达目的地：Dead
wait()、notify()和notifyAll()是 Object类 中的方法 ；
Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、 notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。
28.final关键词的一些总结
final可以用来修饰，类，方法，变量
修饰类:类不可继承，final类中的所有成员方法都会被隐式地指定为final方法。
修饰方法:方法不可重写
修饰变量:对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象，如果是全局变量必须要在声明的时候指定初始值，如果是局部变量，可以在后面指定初始值
29.java当中的异常处理
Java异常类层次结构图
在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 Throwable类。Throwable： 有两个重要的子类：Exception（异常） 和 Error（错误） ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
Exception（异常）:是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 异常由Java虚拟机抛出。NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）、ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和 ArrayIndexOutOfBoundsException （下标越界异常）。
注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。
Throwable类常用方法
public string getMessage():返回异常发生时的详细信息
public string toString():返回异常发生时的简要描述
public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
public void printStackTrace():在控制台上打印Throwable对象封装的异常信息
异常处理总结
try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。
在以下4种特殊情况下，finally块不会被执行：
在finally语句块中发生了异常。
在前面的代码中用了System.exit()退出程序。
程序所在的线程死亡。
关闭CPU。
30.java当中有些字段不想被序列化，怎么办?
对于不想被序列化的字段，可以使用transient修饰。
transient关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。
31.获取键盘输入值的2种方法
（一）通过scanner
package com.xd.map;
import java.util.Scanner;
public class Test5 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
String str=input.nextLine();
System.out.println(str);
}
}
（二）通过BufferedReader方法
package com.xd.map;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test5 {
public static void main(String[] args) throws IOException {
BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
String str=input.readLine();
System.out.println(str);
}
}
32.java当中的内存结构分析
说明:常量与静态的变量，方法存放在方法区，其他的普通成员变量存放在堆区
图解说明
package com.xd.map;
class Car{
public String name;
public String color;
public float price;
public void say() {
System.out.println("买车花费总价");
}
}
public class Test6 {
public static void main(String[] args) {
Car car=new Car();
}
}
此时在内存空间当中的图示如下：
package com.xd.map;
class Car{
public String name;
public String color;
public float price;
public void say() {
System.out.println("买车花费总价");
}
}
public class Test6 {
public static void main(String[] args) {
Car car=new Car();
car.color="黄色";
car.name="大黄蜂";
car.price=1000000;
}
}
package com.xd.map;
class Car{
public String name;
public String color;
public float price;
public void say() {
System.out.println("买车花费总价");
}
}
public class Test6 {
public static void main(String[] args) {
Car car=new Car();
car.color="黄色";
car.name="大黄蜂";
car.price=1000000;
car.say();
}
}
