java基础与c++区别合集

1.

创建对象并不可以直接使用，需要借助 new 语句，还有类后面没有分号。一般类放在一个java源文件中；

class Student
{ 
int result;
}
student a;

此时的a 是个空对象，

a=new Student();
//或 定义和初始化一起做
Student a=new Student();

其实就是系统给变量result分配内存，然后返回引用，赋值给对象a，也就是交给a 控制；

2.

标识符，除了字母，下划线，和数字组成外，还有美元符号，长度不受限，java对字母分大小写（字母包含中文等各种字符，因为用的是Unicode标准字符集）

3.

输入：Scanner类， 创建该类的对象，用该对象调用其函数来进行操作,下面是操作语句：

Scanner reader = new Scanner(system.in);

例：

class People
{ 
int age;
}

import java.util.Scanner;
public class Example
{
    public static void main(String args())
    {
    People a=new People();
    Scanner reader= new Scanner(System.in);
    zhang.age=reader.nextInt();
    }
}

有以下函数：
nextBoolean（）、nextByte（）、nextInt（）、nextFloat（）、nextShort（）、nextLong（）、nextDouble（）

输出：System.out.println 或 System.out.println（），可以输出串值，表达式的值，前者输出且换行，后者则不会换行；

System.out.println(m+"个数的和为"+sum);
//m 和sum 为变量

注意：两个语句都不能出现回车内容，但可以用+把他们串起来
同时java继承了c语言的格式输出；

4.数组

数组声明：
类型 数组名【】；
或
类型【 】数组名；（二维也一样）

（1） java 不允许声明数组的时候给出长度；需要用过new 来分配空间
例：

int a[];
a=new int[12];

声明时候同时初始化：

int a[]=new int[12];

（2）构成二维数组的一维数组不一定要有同样的长度，可以指定多长；

int a[][]=new int[3][];
a[0]=new int [6];
a[1]=new int [7];
a[2]=new int [8];

（3）java允许使用int型变量的值指定数组的元素的个数，例：

int size =10;
int a[]=new int [size];

（4）length的使用

float a[]=new float[7];
int b[][]=new int [3][6];
a.length则会是 7;
b.length则会是3；注意显示一维的

（5）java允许数组引用传递，如果是c++/c是不允许的；

int a[]={4,5};
int b[]={6,7};
a=b;

（6）如果字符数组a，在System.out.println(a)语句中，输出的是整个素组元素
（7）for（接收变量：数组）

int temp;
int a[]={4,5,6,7};
for(temp:a)
System.out.print(temp);

这样就可以循环输出了
（8）使用toString，以字符串输出格式；

import java.util.Arrays
int a[]={4,5,6,7};
System.out.print(Arrays.toString(a));
结果会是：【4,5，6,7】

5.

java 的成员变量声明时可以同时初始化，但其他操作只能是在类的方法中进行

class A
{ 
int a=5;
char b='o';
int c;
c=7;//非法语句，出错
}

6.创建对象

class People
{ 
int age;
float height;
double weight;
}
class Example
{ 
public static void main(String args[])
{ 
People s;
s=new People();
}
}

需要用 new 动态的分配实体，没有使用new的，将会视为空对象，编译器不对空对象进行检查，所以值得注意；

7.垃圾收集

java不像c++有析构函数，而是有自己的“垃圾收集”机制，这种机制周期性地检查某个实体是否已不再被任何对象拥有（引用），如果发现这样的存在，就释放实体占用的 内存空间；
注：如果希望java虚拟机立刻进行垃圾收集，则可以用System类调用gc（）方法；

8.关联关系与依赖关系

关联关系：如果A类中成员变量是用B类声明的对象，那么A和B是关联关系；
依赖关系：如果A类中某个方法的参数是B类对象
或某个方法的返回数据类型是B对象，则是依赖关系；

9.这点跟c++基本一致

使用static 的是类变量，或类方法；反之是实例变量，或实例方法
二者区别：

1. 多变量時，实例变量空间单独，静态的是一个类一个内存空间
2. 类名直接访问类变量，类变量在在该类被加载到内存的时候就分配内存，而实例变量在没有创建对象的时候是没有分配内存的，类变量的内存空间知道程序退出运行，才释放占有的内存
3. 类变量似乎破坏了封装性，当对象调用实例方法時，该方法中出现的类变量也是该对象的变量，只不过这个变量和其他对象共享而已

10.实例方法和类方法的区别

1. 类的实例方法不会直接分配入口地址，只有创建对象后才有；且当创建第一个对象时，类中的实例方法分配了入口地址，当再创建对象时，不再分配入口地址，也就是，方法的入口地址被所有的对象共享，当所有对象不存在時，方法的入口地址才被取消。实例方法可以用实例变量和类变量
2. 类方法，在类被加载内存时，就分配了了入口地址，所以所有对象可以调用执行，同时可以通过类名直接调用；实例方法只能通过对象调用；类方法不可以操作实例变量；
3. 如果一个方法不需要操作实例成员变量就可以实现某种功能，就可以考虑将这样的方法声明为类方法；好处是，避免创建对象浪费空间；

11.this关键字

class B
{
void f()
{ 
int x;
static int y;
this.g();
B.h();
}
void g(int x,int y)
{
this.x=x;//冲突时，this不省略
B.y=y;//冲突时，类名不省略
System.out.println("ok");
}
static void h(){System.out.println("hello");}
}

this不能出现类方法中，这是因为，类方法可以通过类名直接调用。这时，可能还没有任何的对象产生迹象；

12.包

包可以区分，当在不同的java源文件中，有相同名字的类，相当于地址吧；当没有声明哪个包時，则认为時无名包；
package 包名;
必须将源文件编译的字节码文件放在包名的目录中
例1：
package tom.k;
则该源文件存放目录应该是：
···\tom\k
例2：
将源文件放在C：\1000\tom\k中
然后在目录1000下编译源文件：
C：\1000>java.tom.k.主类名（即包名.主类名）
那么字节码文件会默认保存在C：\1000\tom\k中

13.import解决不同包问题

import java.util.*;
表示引入包中所有的类
例：引入包的Date类

import java.util.Date;
class Example
{
public static void main(String arg[])
{ 
Date date=new Date();
System.out.printlin(date);
}
}

14.访问权限

java分为四类：public，protected，友好，private
这四种权限，以上权限由大到小
友好：即不写任何权限，就为友好权限；

1. 类变量或类方法在某个类中定义为私有的private，那么在另外的类中是不可以直接用类名调用点的；
2. 当一个类与另外一个类属于同个包时，后者可以通过对象或者类名直接调用友好变量，友好方法，类友好变量和类友好方法；（这一点个protected一样的）
3. 不能用protected 和 private修饰类

15.可变参数

可以解决函数传递参数时反复声明参数的冗余工作；

public class Computer
{ 
public int getSum(int...x)
{ 
int sum=0;
for(int i=0;i<x.length;i++)
sum=sum+x[i];
}
/*这里也可以*/
/*
for(int temp:x)
 sum=sum+temp;
*/

return sum;
}

public class Example
{
public static void main(String arg[])
{
Computer c =new Computer();
int result=c.getSum(1,2,3,4);
System.out.println("和为："+result);
}
}

15.继承

子类继承父类后，继承的成员或方法的访问权限不变
例：当父类和子类属于同个包的情况下

class A
{ 
public int a;
int i;
}
class B extends A
{ 
int b;
}
class Example
{ 
void main()
{ 
B c=new B();
c.a=1;
c.b=4;
c.i=2;
}

当属于不同包的情况下，子类不能继承父类中的private 和友好 这两种类型的变量或者方法；
如上例：在该情况下，c.i 是错误的调用

16.隐藏与重写

• 当父类和子类的成员变量或方法相同名字时，子类会将父类继承过来的隐藏掉，然后用自己的变量或者方法；
• 如果父类方法的类型是“类”，那么允许子类的重写方法的类型是父类返回值类型的“子类”

class People
{ 
People haha(int a)
{People a=new People()
return a;
}
}
class Student extends People
{ 
Student haha (int a)//重写
{ Student b=new Student();
return b;
}
}

1. 重写时可以修改访问权限修饰符和返回值，但方法名和参数类型及个数都不可以修改；
2. 子类继承父类后，重写父类 f（）方法，那么子类对象调用 f（）则一定是子类重写的方法；
3. 重写的方法可以操作继承的成员变量、调用继承的方法，也可以操作新增的成员变量。调用新定义的其他方法，但无法操作被子类隐藏的成员变量和方法。
4. 重写的两个注意的点：（1）子类重写父类方法時要保持类型一致；（2）子类重写父类的方法后，该方法的权限必须大于或等于父类方法的权限；

class A
{ 
protected float f(float x,float y)
{ 
return x-y;
}
}
class B extends A
{ 
float f(float x, float y)//非法，降低了访问权限
{return x+y;}
}
class C extends A
{ 
public f(float x, float y)//合法，提高了访问权限
{return x*y;}
}

16.super关键字

被隐藏的变量或者方法由 super负责，当子类中想使用被隐藏了的成员变量或方法就需要使用关键字super。

class People
{ 
int x=100; 
}
class Student extends People
{ 
int x=18;
void getAge()
{
super.x=x;
System.out.println("年级是:"+super.x);
}
}
class Example
{
void main()
{
Student a=new Student();
a.getAge();
} 
}

17.final关键字

1. 如果final 关键字修饰父类中的一个方法，那么这个方法不允许子类重写
2. 如果成员变量或局部变量被修饰为final ， 就是常量，且必须在声明时，就初始化，否则之后是没法改动的；但可以作为参数；

class A
{ 
final double IP=3.1415;
public double getArea(final double r)
{ 
returnn IP*r*r;
}
public final void speak()
{System.out.println("您好");}
}
class Example
{ 
public static void main(String arg[])
{ 
A a= new A();
System.out.println("面积"+a.getArea(100);)
}
}

18.对象的上转型对象

这点很想像c++的子类对象引用赋值给父类指针，只能通过指针调用父类的的变量或者方法；
还可以实现多态

1. 上转型对象:可以调用从父类继承的变量，或者被子类隐藏的变量，同时可以调用继承过来的方法和子类重写的方法
2. 可以将对象的上转型强制转换到一个子类的对象
3. 不可以将父类对象赋值给子类对象

class A
{
void get_t()
{ 
System.out.printlin("hello");
}
}
class B extends A
{ 
void get_t()
{ System.out.printlin("ok");
}
void second()
{ System.out.printlin("thanks");}
}
class Example
{
 void main(String arg[])
 { 
 A a=new B();
 a.get_t();//这里输出的结果是：ok 为什么呢？因为这里调用的子类重写的方法，所以显而易见，在重写>隐藏
 B b=(B)a;//强制将父类对象转换为子类对象
 //这一句奇怪的一点是，不同通过new B（）为 b创建对象
 }
}

19.abstract关键字

与c++ 的虚函数和纯虚函数相似
abstract int min (int x , int y);
抽象类只许声明不许实现，不允许abstract 和 final 同时出现

1. 抽象类可以有抽象的方法和非抽象的方法（与接口区别开来）
2. 不能创建抽象类的对象，
3. 一个非抽象类继承抽象类，则它必须重写父类的抽象方法，给出实体
4. 如果是抽象类继承抽象类，则它可以继承抽象方法，或者重写这个抽闲方法

abstract class A
{ 
abstract int sum(int x,int y);
int sub(int x,int y)
{ 
return x-y;
}
}
class B extends A 
{ 
int sum(int x,int y)//重写了父类的抽象方法
{
return x+y
}
}

20.接口

1. 接口体中含有常量（没有变量）和抽象方法两部分，所以常量的访问权限一定是public，方法以一定是abstract， java允许接口中可以省略public和abstract修饰
2. 用关键字interface声明接口，用implement声明自己实现类，如果要实现多个接口则用逗号隔开；
3. 非抽象类实现了了接口，则该类必须重写接口中的所有方法，需要注意的是，我们省略的public 此时必须写出来，不然变成友好型降低了访问权限，而abstract要去掉；
4. 接口中的常量可以用接口名直接调用
5. 当不希望某些类通过继承拥有一些相同的方法的时候，可以考虑接口

Computable.java

public interface Computable{
int MAX=100;
int f(int x);

China.java

public class China implements Computable{
int nember;
public int f(int x){
int num=0;
for(int i=1;i<=x;i++)
{sum =sum+i;}
return sum;
}

Japan.java

public class Japan implements Computable{
int number;
public int f(int x)
{return 46+x;}
}

main.java

public clas Example{
public static void main(string arg[])
{China zhang;
 Japan henlu;
 zhang=new China();
 henlu=new Japan();
 zhang.number=28+Computable.MAX;
 henlu.number=14+Computable.Max;
 System.out.println("zhang的学号"+zhang.number+"zhang 求和结果"+zhang.f(100));
 System.out.println("henlu的学号"+henlu.number+"zhang 求和结果"+henlu.f(100));
 }
 }

21.接口回调

1. 类型为接口的变量叫做：接口变量
2. 接口回调：指将实现某一接口的类的对象的引用赋值给接口变量，让接口变量调用该类实现接口的方法叫接口回调，很像前面的上转型

该例也是接口多态的体现

interface ShowMessage
{ void show(string s);
}

class TV implements ShowMessage
{ 
public void show(string s)
{ System.out.println(s);}
}

class PC implements ShowMessage{ 
public void show(string s)
{ System.out.println(s);}
}

public class Example{
public static main(String arg[])
{ShowMessage sm;//接口变量
sm=new TV();//接口中放对象的引用
sm.show("我家的电视");//接口回调
sm=new TV();//接口中放对象的引用
sm.show("我家的PC");//接口回调
}

从上面的例子我们可以看出需要反复对 sm 接口变量重新赋值新对象的引用，再多次调用sm.show() 方法，那么接下的内容是解决这些重复的操作；

接口参数

上例：可以改成

interface ShowMessage
{ void show();
}

class TV implements ShowMessage
{ 
public void show()
{ System.out.println("我家的TV");}
}

class PC implements ShowMessage{ 
public void show()
{ System.out.println("我家的PC");}
}
class haha{
void totall(ShowMessage sm)
{sm.show()}
}
public class Example{
public static main(String arg[])
{
haha a=new haha();
a.totall(new TV());
a.totall(new PC());
}

某些问题需要继承才能解决，像：子类除了需要重写父类的abstract方法，还需要从父类继承一些变量或一些重要的非abstract方法，就可以考虑用abstract

某个问题不需要继承来解决，只需要若干类给出某些重要的abstract的实现细节，就可以考虑使用接口