C++与JAVA的语法差异

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量756 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45093118/article/details/120109724
版权

一、差异点

1. 规范标准

  1. JAVA中的对象都是new出来的，只要创建对象，就会在堆中开辟一块新的空间
  2. 方法实在栈中执行的，因此只要调用方法，就会在栈区开辟一块空间来执行该方法
  3. 引用类型(数组，类，接口)传递的时地址值
    在这里插入图片描述
    问题点：子类调用父类构造方法的方式有哪些？初始化父类的方式有哪些？
public class ClassName{
  //成员变量  private
  //构造方法
  //无参构造方法【必须】
  //满参构造方法【建议】
  //getXxx()
  //setXxx()
  //成员方法	
}

2. 权限修饰符

在这里插入图片描述

3. 查看API

能够知道帮助文档的使用步骤
   打开api
   点击显示
   点击索引,在输入框中输入要查找的内容
   查看包
   查看类的解释说明
   查看类的构造方法
   查看类的成员方法

3. 匿名对象

匿名对象只能使用一次，作用域在也只在当前行

package OO.test

class Student {
	public String name;
	public int age;
	
	public void show() {
		System.out.println(name + age);
	}
}

public class Test {
	public static void main(String[] args) {
		new Student("哈哈哈", 18).show();
	}
}

4. 代码块

  1. 构造代码块：在类内部，成员方法的外部，每调用一次构造函数就会执行一次

  2. 静态代码块：在类内部，成员方法的外部，只在加载类的时候调用一次

  3. 局部代码块：在成员方法内部，提高阅读便利，节省内存空间，意义不大

  4. 执行优先级: 静态代码块 > 构造代码块 > 构造方法

    public class Test {
    private int a = 0;
    {					//构造代码块，可以记录定义了多少个对象
        a++;
        System.out.println("构造函数被调用的次数：" +a);
    }
    static {			//静态代码块，只被调用一次，如驱动加载等场景
        System.out.println("静态代码块");
    }
    public static void main(String[] args) {
        {				//局部代码块，提高阅读性，代码块结束即释放内部变量
            int a = 10;
            int b = 20;
        }
	} 
}

5. 反射

获取类对象
一个类的Class对象都只有一个。

// 1.方式一:通过类名.class获得
Class<Student> c1 = Student.class;

// 2.方式二:通过对象名.getClass()方法获得
Student stu = new Student();
Class<? extends Student> c2 = stu.getClass();

// 3.方式三:通过Class类的静态方法获得： static Class forName("类全名")
Class<?> c3 = Class.forName("com.itheima.demo2_Class对象的获取.Student");

//:一个类只有一个字节码对象(Class对象)
System.out.println(c1 == c2);// true
System.out.println(c1 == c3);// true

获取成员属性

Class类中与Field相关的方法
* Field getField(String name);
    *  根据成员变量名获得对应Field对象，只能获得public修饰
* Field getDeclaredField(String name);
    *  根据成员变量名获得对应Field对象，包括public、protected、(默认)、private的
* Field[] getFields();
    * 获得所有的成员变量对应的Field对象，只能获得public的
* Field[] getDeclaredFields();
    * 获得所有的成员变量对应的Field对象，包括public、protected、(默认)、private的

获取构造方法

Class类中与Constructor相关的方法 
1. Constructor getConstructor(Class... parameterTypes)
        * 根据参数类型获得对应的Constructor对象。
        * 只能获得public修饰的构造方法
 2. Constructor getDeclaredConstructor(Class... parameterTypes)
        * 根据参数类型获得对应的Constructor对象
    	* 可以是public、protected、(默认)、private修饰符的构造方法。
 3. Constructor[] getConstructors()
        获得类中的所有构造方法对象，只能获得public的
 4. Constructor[] getDeclaredConstructors()
        获得类中的所有构造方法对象
    	可以是public、protected、(默认)、private修饰符的构造方法。

Constructor对象常用方法
1. T newInstance(Object... initargs)
 	根据指定的参数创建对象
2. void setAccessible(true)
   设置"暴力反射"——是否取消权限检查，true取消权限检查，false表示不取消

获取成员方法

Class类中与Method相关的方法
* Method getMethod(String name,Class...args);
    * 根据方法名和参数类型获得对应的构造方法对象，只能获得public的

* Method getDeclaredMethod(String name,Class...args);
    * 根据方法名和参数类型获得对应的构造方法对象，包括public、protected、(默认)、private的

* Method[] getMethods();
    * 获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的

* Method[] getDeclaredMethods();
    * 获得类中的所有成员方法对象，返回数组,只获得本类的，包括public、protected、(默认)、private的

执行成员方法

Method对象常用方法
*  Object invoke(Object obj, Object... args)
    * 调用指定对象obj的该方法
    * args：调用方法时传递的参数
*  void setAccessible(true)
    设置"暴力访问"——是否取消权限检查，true取消权限检查，false表示不取消

实例

class ReflectTest{
	//通过类加载器，加载配置文件
	ClassLoader classLoader = ReflectTest.class.getClassLoader();	//获取当前类的类加载器
	InputStream is = classLoader.getResourceAsStream("properties");	//获取配置文件输入流
	Properties pro = new Properties();								//创建配置文件对象
	pro.load(is);													//加载配置文件到配置文件的对象
	//获取配置文件中数据
	String className = pro.getProperty("className")					//获取配置文件中的类名
	String methodName = pro.getProperty("methodName");				//获取配置文件中的方法名
	//使用获取的数据
	Class cls = Class.forName(className);							//将获取的类名加载到内存
	Object obj = cls.newInstance();									//获取类的对象
	Method method = cls.getMethod(methodName);						//获取对象的方法
	method.invoke(obj, "abc");										//传入参数执行方法
}

二、面向对象

1. 继承

  1. Java是单继承，不允许继承多个类，使用extends关键字继承
  2. 构造方法不可以被继承，私有成员可以被继承，但不能被访问
  3. 非私有成员，子类对象会优先访问子类中找
  4. Java中没有virtual关键字，因此将C++中重写和重定义都合并成了重写，即在子类中重新实现父类中的函数，重写也可以作用在多态。
  5. 重写的方法权限要>=父类的方法权限，且使用@Override注解，可以校验也可以提高代码可读性
class Fu {
	private String name;
	private int age;
	
	public void show() {
		System.out.println("这是父类");
	}
}
class Zi extends Fu{
	@Override
	public void show() {
		System.out.println("这是子类");
	}
}

public class Test {
	public static void main(String[] args) {
		Zi zi = new Zi;
		zi.show();	//这是子类，(继承)

		Fu zi = new Zi;
		zi.show();	//这是子类，(多态)
	}
}

2. 关键字

this：存储的“当前对象”的引用；

this可以访问：本类的成员属性、成员方法、构造方法；
this()可以在本类的一个构造函数中调用另一个构造方法，但必须在函数中是第一行。

class Cls {
	Cls(String name, int age) {
		System.out.println("有参构造")
	}
	Cls() {
		this("haha", 18);				//调用有参构造函数
		System.out.println("无参构造")
	}
}

super:存储的“父类对象”的引用；

super可以访问：父类的成员属性、成员方法、构造方法；
子类的构造方法默认会调用父类的空构造方法，super()可以在子类的一个构造函数中调用父类构造方法，来初始化从父类继承过来的属性，但必须在函数中是第一行。

class FU {
    public String name = "haha";
    public int age = 18;

    public FU() {
        System.out.println("父类无参构造");
    }
    public FU(String name, int age) {
        System.out.println("父类有参构造");
    }
}

class Zi extends FU {
    public Zi(){
        System.out.println("子类无参构造");
    }
    public Zi(String name, int age) {
        super(name, age);		//调用父类有参构造
        System.out.println("子类有参构造");
    }
}

final：同const

final关键字就是C++中的const关键字：修饰的类不能被继承，修饰的方法不能被重写，修改时的变量只能赋值一次

3. 抽象类

  1. 被abstract关键子修饰的类就是抽象类，被修饰的方法就是抽象方法。
  2. 抽象类无论是否有抽象方法，都无法实例化；若类中有抽象方法，则必须定义成抽象类。
  3. Java中的抽象类与C++中是相同的概念，区别只是修改的关键字是abstract而非virtual，名字是抽象方法而非虚函数
abstract class Fu {
	int a;
	public Fu(){}
	public abstract void absFunc(); 
}
class Zi extends Fu{
	@Override 
	public void absFunc() {		//重写父类
		int b = 10;
	}
}

模板设计模式：模板已经定义了通用架构，使用者只需要关心自己需要实现的功能即可！

public abstract class Driver {
    public void driveCar(){
        System.out.println("开门");
        System.out.println("点火");
        ziShi();
        System.out.println("刹车");
        System.out.println("熄火");
    }
    public abstract void ziShi();
}
public class NewDriver extends Driver {
    @Override
    public void ziShi() {
        System.out.println("双手紧握方向盘");
    }
}
public class OldDriver extends Driver {
    @Override
    public void ziShi() {
        System.out.println("右手握方向盘左手抽烟");
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建新司机对象
        NewDriver d1 = new NewDriver();
        d1.driveCar();
        // 创建老司机对象
        OldDriver d2 = new OldDriver();
        d2.driveCar();
    }

}

4. 接口

定义

  1. 在JDK 7之前，java中的接口除了语法之外，同C++中的接口没有区别，接口类中只可以定义抽象方法和public static final修饰的常量，JDK8添加了默认方法和静态方法，JDK9添加了私有方法。
  2. 接口使用interface而非class，也会被编译成.class，但其本身不是类，而是另一种引用数据类型(数组、类、接口)
  3. 接口中的静态方法不可以被继承，而类中时可以被继承的
public interface IA {
	public static final int NUM1 = 10;	//常量
	int NUM2 = 20;
	
	public abstract void method1();	//凑想方法
	public default void method2() {}	//默认方法
	public static void method3() {}	//静态方法
	private void method4(){}	//私有方法
}

实现

  1. 接口只能通过implements来实现类，不能实例化，所以和抽象类很类似
  2. 接口可以多继承，实现类可以多实现，也可以多实现+继承。
public interface IA {
	public void show1();	//无论加不加abstract关键字，都会默认为抽象方法
}
public interface IB {
	public void show2();
}

public interface IC extends IA, IB {	//接口多继承
}

class Fu {
	public void show3();
}
public class Zi extends Fu implements IA, IB {	//先继承，后实现

}

多继承、多实现、继承与实现冲突时

public interface IA {
	public static final int NUM1 = 10;	//常量
	int NUM2 = 20;
	
	public abstract void method1();		//凑想方法
	public default void method2() {}	//默认方法
	public static void method3() {}		//静态方法
	private void method4(){}			//私有方法
}
public interface IB {
	public static final int NUM1 = 10;	//常量
	int NUM2 = 20;
	
	public abstract void method1();		//凑想方法
	public default void method2() {}	//默认方法
	public static void method3() {}		//静态方法
	private void method4(){}			//私有方法
}

class Fu {
	public static final int NUM1 = 10;	//常量
	int NUM2 = 20;
	
	public abstract void method1();		//凑想方法
	public default void method2() {}	//默认方法
	public static void method3() {}		//静态方法
	private void method4(){}			//私有方法
}
  1. 接口多实现时冲突
    公有静态常量会编译报错，公有抽象方法只需重写一个，公有默认方法需要重写最终版本，公有静态方法无法继承不冲突，私有方法只能在本接口中用不冲突
  2. 接口多继承时冲突
    公有静态常量会编译报错，公有抽象方法只需重写一个，公有默认方法需要重写最终版本，公有静态方法无法继承不冲突，私有方法只能在本接口中用不冲突
  3. 继承又实现时冲突
    公有静态常量会编译报错，公有抽象方法只需重写一个，公有默认方法优先访问父类默认方法，公有静态方法只会访问父类静态方法，私有方法不冲突

注意：子类重写默认方法时要加default，实现类实现默认方法时不需要加default

5. 多态

概念

  1. 静态方法无法实现多态
  2. 多态的形式分为普通多态，抽象父类多态，父接口多态
interface IA {}
class Fu {}
abstract class Fu1{}
class Zi extends Fu implements IA{}
class Zi extends Fu1{}
class Zi implements IA{}
public class Demo{
    public static void main(String[] args){
        IA c = new Zi();	//父接口
        Fu c = new Zi();	//普通父类	
        Fu1 c = new Zi();	//抽象父类
}

使用场景：将指向子类的父类对象作为变量、参数、返回值，此时无法调用子类的独有的方法及属性。

类型转换

子类对象转父类对象可以自动转换，父类对象转子类对象需要强制转换，强转之前可以用instanceof关键字来判断是否可以强转。

Animal anl = new Dog();		//自动转换
Dog dog = (Dog)anl;			//强制转换

Animal anl = new Animal ();
Dog dog = (Dog)anl;			//会报错，父类转子类时，父类的对象一定要指向子类

//使用instanceof判断是否可以强转
if(anl instanceof Dog) {	//注意：Dog是类名而非对象名
	Dog dog = (Dog)anl;
}

6. 内部类

  1. 将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
  2. 内部类可以直接访问外部类的成员，包括私有成员。外部类要访问内部类的成员，必须要建立内部类的对象。
class Body {
	private int num = 10;
	class Heart{		//内部类
		private int num1 = 100;
		public int show() {
			return num;	//直接访问外部类的私有成员
		}
	}
	public int show1() {
		return num1;	//会报错，无法直接访问
	}
}

public class Test {
	public static void main(String[] args) {
		Body.Heart hb = new Body().new Heart()	//定义内部类对象			
	}
}

匿名内部类

匿名内部类的作用只有一个就是简化代码，其本质是匿名 子类对象
如：如果方法的形参为抽象类或接口，那么就需要向方法传入子类的对象，而创建子类的对象步骤繁琐，因此可以直接创建匿名内部类并传入

interface IA {
	public abstract void show1();
}

class Fu() {
	public abstract void show2();
}

public class Test {
	public static void main(String[] args) {
		method(new IA() {	//创建匿名内部类
			@Overrite
			public void show1() {
				int i = 10;
			}	
		);
	
		method(new Fu() {	//创建匿名内部类
			@Overrite
			public void show2() {
				int i = 10;
			}	
		);
	}
	public void method(IA ia) {	//需要传入实现类对象
		ia.show1();
	}
	public void method(Fu fu) {	//需要传入子类对象
		fu.show2();
	}
}
打打打劫
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java和c++语法区别
05-27
java和c++语法区别语法上的比较，也举出了一些相同点
C++与java语法的异同整理
Dan的博客
05-04 3885
文章目录C++中的虚函数和JAVA中的抽象方法区别C++虚函数与JAVA中抽象函数比较关于接口与抽象类： C++中的虚函数和JAVA中的抽象方法区别 C++虚函数与JAVA中抽象函数比较 1：java中没有虚函数的概念，但是有抽象函数的概念，用abstract关键字表示，java中抽象函数必须在抽象类中，而且抽象 函数不能有函数体，抽象类不能被实例化，只能由其子类实现抽象函数，如果某个抽象类的子...
c++ java语法区别,Java 和 C++ 语法之间的区别
weixin_39912368的博客
03-18 97
Java 和 C++ 语法之间的区别main 方法Java//java 的函数必须写在类里class HelloWorld{public static void main(String args[]){System.out.println( "Hello, World" );}}复制代码C++//C++ 的函数可以写在任意地方 没有限制int main( int argc, char* argv[...
java和C++语法上的一些区别
浮白
02-21 3617
1)java是解释性语言,java程序在运行时类加载器从类路经中加载相关的类,然后java虚拟机读取该类文件的字节,执行相应操作.而C++编译的 时候将程序编译成本地机器码.一般来说java程序执行速度要比C++慢10-30倍.即使采用just-in-time compiling (读取类文件字节后,编译成本地机器码)技术,速度也要比C++慢好多. 2)java程序有要从网络上加载类字节
浅析Java语言与C++语言的区别
Hunter_pcx的博客
11-21 3233
1.    java中类继承，如果父类方法要重写，不用加任何关键字；而C++却要加 virtual 关键字。 2.    Java中，super可以表示父类，this表示类本身。 3.    C++的类可以多继承，即一个类有多个父类；而java只能单继承，即一个类只能由一个父类继承。 4.    C++类继承采用符号“：”，而java类继承采用关键字“extends”。 5.    C++
c java语法区别_C++与java语法的异同整理
weixin_39995764的博客
03-03 497
文章目录Java与C++与基础语法异同java的认知& java与C++的异同C++中的虚函数和JAVA中的抽象方法区别C++虚函数与JAVA中抽象函数比较关于接口与抽象类：Java与C++与基础语法异同javaC++double 要用%f；double 要用%d布尔型：boolean；布尔型：bool字符型占2个字节,Unicode编码格式字符型占1个字节,Assci编码格式If , w...
JAVA与C++ 语法差异
sunflower_della的博客
05-16 1535
一、基础类型 java中8种基础类型： 1. byte数据类型是8位、有符号的，以二进制补码表示的整数，默认值为0 表达范围是：-128（-2^7） ~ 127（2^7-1） 取值范围已经定义在包中：Byte.SIZE，Byte.MIN_VALUE，Byte.MAX_VALUE 2.short数据类型是16位、有符号的以二进制补码表示的整数，默认值为0 ...
科普:java与C++的区别
记录 IT 领域经验与见解的博客
04-10 2359
由于Java语言需要虚拟机来解释执行程序，因此相对于C++语言来说，Java语言的执行速度会慢一些。但是，由于Java语言具有自动内存管理的特性，因此可以减少内存泄漏等问题，从而提高了程序的稳定性。Java语言具有很好的跨平台性，由于Java程序只需要在不同平台上安装虚拟机即可运行，因此不需要为不同平台编写不同的代码。而C++语言需要针对不同的操作系统编写不同的代码，因此不具有很好的跨平台性。总之，C++语言和Java语言都是非常优秀的编程语言，它们各自具有其应用领域和优缺点。三、C++与Java的编译。
C++和Java的语法区别整理
大迪deblog
02-06 1047
#前言： 当使用某种语言开发做一段项目后，再切换其他语言时，总是会出现一些不适用的情况，虽然大多数语言都是相通的，但还是有必要先整理他们的区别，方便切换时使用。 #正文： （1）创建和销毁对象： C++： Java： （2） （3） （4） （5） （6） （7） （8） （9） （10） ...
C++与Java的语法区别
热门推荐
只谈技术
07-04 1万+
 C++与Java的语法区别首先，两个大的不同是主函数和怎样编译的不同，接下来是许多小的区别。main 函数C++//自由浮动的函数int main( int argc, char* argv[]){    printf( "Hello, world" );}Java// 每个函数都必须是一个类的一部分;当java 运行是一个特定类的主函数会被调用// (因此你可以让每个类都有一个main
C++与Java比较(转)
keke_Xin的专栏
04-30 3572
“作为一名C++程序员，我们早已掌握了面向对象程序设计的基本概念，而且Java的语法无疑是非常熟悉的。事实上，Java本来就是从C++衍生出来的。”　　然而，C++和Java之间仍存在一些显著的差异。可以这样说，这些差异代表着技术的极大进步。一旦我们弄清楚了这些差异，就会理解为什么说Java是一种优秀的程序设计语言。本附录将引导大家认识用于区分Java和C++的一些重要特征。　　(1) 最大的障碍...
《Java基础复习》—常识与入门
01-21
计算机能直接识别的是机器指令，机器指令的封装是汇编语言，汇编语言再向上是高级语言如C,C++,Java 因为机器的差异性，汇编语言要想编译为适应不同的机器的指令，就需要中间件——操作系统。 应用程序=算
Java Bug模式详解
02-11
2.4 实现方案与规范的差异 2.5 利用素材建立经济有效的规范 2.5.1 通过测试来排除 规范错误 2.5.2 单元测试的缺陷 2.6 小结 第3章 调试和开发过程 3.1 将调试当作科学试验 3.1.1 逐步规范化、整 合并发行...
我的第一个C语言
04-24
我的第一个C语言C语言是一门通用计算机编程语言，广泛应用于底层...C语言是一门面向过程的计算机编程语言，与C++，Java等面向对象的编程语言有所不同。 其编译器主要有Clang、GCC、WIN-TC、SUBLIME、MSVC、Turbo C等。
最简洁，占用最小、最易操作的代码比对工具
06-10
有时，我们需要对一个文件的不同版本进行比较，以了解其差异。...支持像 C++、Python、Java、XML 等语言的语法高亮显示。 能够直接在 Diffuse 中编辑文件。 支持 UTF-8 编码。 可以使用快捷键轻松导航。
Haxe 3.0垮平台开源编程语言
09-06
无视平台差异，在不同平台之间轻松切换。 统一的语法以及特性。 一次编写，处处“自动”编译。 解救跨平台开发的一次尝试 由于它可以自动编译生成多种类型的代码，所以无论是iOS、Android、Windows Phone平台之间的...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 737
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 820
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1733
c++中string的模拟实现，面试必会知识点
c++与java语法差异比较
05-18
C++ 和 Java 都是面向对象的编程语言，但它们的语法和特性有很多不同之处。下面是一些主要的差异： 1. 编译与解释： C++ 是一种编译型语言，而 Java 是一种解释型语言。 2. 内存管理： C++ 允许手动分配和释放内存，而 Java 有自动垃圾回收机制，程序员不需要手动管理内存。 3. 异常处理： C++ 使用 try-catch 块来处理异常，而 Java 使用 try-catch-finally 块。 4. 多重继承： C++ 支持多重继承，而 Java 不支持。 5. 运算符重载： C++ 允许运算符重载，而 Java 不允许。 6. 指针： C++ 支持指针，而 Java 不支持。 7. 数据类型： C++ 有 struct 和 union 数据类型，而 Java 没有。 8. 泛型编程： C++ 使用模板来实现泛型编程，而 Java 使用泛型。 9. 文件处理： C++ 中使用 fstream 类来处理文件，而 Java 使用 java.io 包中的类来处理文件。 以上是一些主要的差异，但实际上两种语言还有很多其他的差异，需要具体的代码实践和深入学习才能更好地理解它们之间的差异。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值