各种语言特性
1.数组
#--python--
list=[1,2,3,4,5]
length=len(list)
index=list.find()
index=list.index(1);
dic={“a”:1,"b":2,"c":3}
#--JavaScript--
list=new Array();
list=new Array(1,2,3,4);
var list=[1,2,3,4];
var length=list.length;
var index=list.indexOf(1);
var dic={a:"1",b:"2",c:"3"}; //jSON对象
#PHP
$list=array();
$list[]="12345";
$dic=array('a'=>"1","b"=>"2","c"=>"3");
$length=count($list)
#Java
int[] list; //double[] list;
list=new int[10]//数组长度
int[] list={1,2,3,4,5};
int[] list=new int[] {1,2,3,4,5};
length=list.length;
#C#
int[] list;
list=new int[10];
int[] list={1,2,3,4,5};
int[] list=new int[] {1,2,3,4,5}; //创建并初始化
int length=list.Length;
list.Rank;//维数
int length=list.GetLength(0)；
Console.WriteLine();
Console.ReadKey();
#C++
int list[10];
int list[]={1,2,3,4,5};
int length=sizeof(list)/sizeof(int);
2.函数
#--Python--
def Add(a:int,b:int)->int:
return a+b
#--JavaScript--
function Add(a,b){
return a+b;
}
var sum=Add(1,2);
#--PHP--
function Add($a,$b){
return $a+$b;
}
#--JAVA--
局部变量不能被声明为 static 变量
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。
final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
父类中的 final 方法可以被子类继承，但是不能被子类重写。final 类不能被继承，没有类能够继承 final 类的任何特性。
public static int Add(int a,int b){
return a+b;
}
#--C#--
public static int Add(int a,int b){
return a+b;
}
#--C++--
int Add(int a, int b){
return a+b;
}
3. if else语句
Python:if elif else: JavaScript:if else if else PHP: if elseif else Java: if else if else C#: if else if else C++: if else if else
4.类
#私有变量this/self 公有变量public
#getter and setter
#构造函数和析构函数
#继承多态
#抽象类和方法 接口
#累的实例化
class Animal:
__privateAge=0 #两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问
publicCountry="China" #公有变量
def __init__(self,name): # 构造函数，在生成对象时调用
print("My name is",name)
def __foo(self):
print("This is a private function!")
def foo(self):
print("This is a public function!")
def getter(self):
print("My age is",__privateAge)
def setter(self,age):
__privateAge=age
print("My age has been set as",__privateAge)
def Shout(self):
print("Shouting!")
def Add(self,x):
y=x+1
print(y)
def __del__: #析构函数，释放对象时使用
print("I'm dying")
class Dog(Animal): #单继承，可以有多个继承
def Shout(self): #重写父类方法
print("Barking")
def Add(self,x):
super().Add(x) #调用父类方法
#多态
class Dog(Animal):
def Shout(self):
print("Barking")
#实例化
dog=Dog("Lighting")
dog.Shout()
# 抽象类，约束子类中必须包含某些方法
class Payment:
def pay(self):
pass # 抽象方法，此处无需实现
注意，抽象类不能被实例化，只能被继承；抽象方法必须被子类方法重写
#微信支付
class WeChatPay(Payment):
def pay(self,money): # 必须实现抽象方法，不实现，实例化的时候会报错
print('微信支付了%s'%money)
#支付宝支付
class AliPay(Payment):
def pay(self,money): # 必须实现抽象方法，不实现，实例化的时候会报错
print('支付宝支付了%s'%money)
#接口类， 约束子类中必须包含父类规定的方法
注意：Python中无接口这个概念
def pay(obj,money):
obj.pay(money)
weixin = WeChatPay()
alipay = AliPay()
#调用者无需关心具体实现细节，可以一视同仁的处理实现了特定接口的所有对象
pay(weixin,100)
pay(alipay,200)
class Site{
constructor(name,url){
this.name=name;
this.url=url;
}
age(){
let date=new Date();
`` return date.getFullYear()-this.year;
}
}
#实例化
let Jun=new Site("JavaScript","https://www.js.com");
#--PHP--
class Animal{
private $age=0;
var $Country="China"; // 类的成员变量通过var声明
var $height;
private $name; // 访问私有变量时，必须使用$this关键字
public function __construct($name){
this->$name=$name
}
public function getAge(){
return $this->$age;
}
public function setHeight($height){
$this->height=$height;
}
function Add($x){
$y=$x+1;
echo $y;
}
public function Shout(){
print "Shouting\n";
}
function __destruct(){
print "销毁".$this->$name."\n";
}
}
#继承
class Dog extends Animal, OtherAnimal{
public function Shout(){
print "Barking\n";
}
public function Add($x){
parent::Add($x); // ::Add($x);
}
final class Animal{} //无法被继承的类
final public function Shout() //无法被继的方法
#实例化
$dog=new Dog;
$dog=new Dog("Lighting");
#抽象类
abstract class Payment{
abstract function pay();
}
final WeChatPay extends Payment{
public function pay($money){
print "微信支付了".$money."元"; // print "微信支付了{$money}"."元";
}
}
final AliPay extends Payment{
public function pay($money){
print "支付宝支付了{$money}"."元\n";
}
}
#接口
#接口的成员是常量
#接口抽象方法是public属性的，不需要absrtact声明
interface Payment{
const TOOL="Payment";
public function pay();
}
class WeChatPay implements Payment{
public function pay($money){
print "支付宝支付了{$money}"."元\n";
}
}
#静态变量 静态方法
#静态变量可在不进行类的实例化的情况下使用
#能够供所有类的对象实例共享
class Animal{
public static $count=5; //一般来说，需要将字段私有化 private static
}
echo Animal::$count;
#拦截
#操作私有属性
__get(调用的变量名);
__set(变量名,变量值);
#--JAVA--
public class Animal{
private int age;
public String Country;
Animal(){
System.out.println("I'm an animal");
}
Animal(int age){
this.age=age;
System.out.println("I'm "+age+" years old");
}
public Shout(){
System.out.println("I'm shouting!");
}
java中有析构函数，但我们一般用不到它，因为java有自动内存回收机制，无需程序员来释放，也就不要担心内存泄露，只不过java中析构函数所采用的方式不是C++中的那样前加~号，在java中 对象析构时会调用void finalize()方法，因此你如果确实需要析构的话就可以为你写的类添加一个void finalize(){}方法，来完成你所需要的工作
protected void finalize(){
Sstem.out.println("正在销毁。。。");
}
}
final class Animal{}
public/private/default/proteted final int Shout(){}
#继承
class Dog extends Animal{
private int age;
Dog(){ // 自动调用父类的无参构造函数
System.out.println("I'm a dog!");
}
public Dog(int age){
super(5);//自动调用父类中有参构造函数
System.out.println("I'm "+age);
this.age.age;
}
void Shout(){
System.out.println("I'm barking!");
}
void ReShout(){
this.Shout();//调用自己的方法
super.Shout(); //调用父类的方法
}
#实例化
Dog d=new Dog();
Dog d=new Dog(3);
#抽象
# 在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口
public abstract class Payment{
private int money;
public Payment(int money){
System.out.println("Constructing a payment!");
this.money.money;
}
public int getMoney(){
return money;
}
}
# 抽象方法
public abstract void pay(int money){};
#接口
# implements可以变相的使java具有多继承的特性
public interface Payment{
public void pay();
}
public interface Chat{
public void chat();
}
public C implements Payment,Chat{}
#--C#--
class Animal{
private int age;
public String Country;
public Animal(){
Console.WriteLine("I'm an animal!");
}
public Animal(int age){
this.age=age;
Console.WriteLine("I'm "+age+" years old!");
}
public Shout(){
Console.WriteLine("I'm shouting!");
}
~Animal(){
Console.WriteLine("正在销毁");
}
class Dog:Animal{
public Dog(){
Console.WriteLine("I'm a dog"); #同样会调用父类的无参构造函数
}
public Dog(int age){
this.age=age;
Console.WriteLine("I'm "+age+" years old!");
public Shout(){
Console.WriteLine("I'm barking!");
}
}
#在子类中的有参构造函数中使用base，明确调用父类有参构造函数。
# 通过调用子类有参构造函数，同样默认会调用父类无参构造函数。
# 实例化
Dog d =new Dog("Lighting");
d.Shout();
# C# 不支持多重继承。但是可以使用接口来实现多重继承
public interface Payment{
int money;
void pay();
}
public interface Chat{
void chat();
}
class Weixin : Payment,Chat{
void pay(int money){
this.money=money;
Console.WriteLine("微信支付"+money+"元");
}
void chat(){
Console.WriteLine("正在进行聊天");
}
}
#抽象
public abstract Payment{
void pay();
}
public abstract void pay();
public override void pay();
#--C++--
class Animal{
private:
int age;
public:
Animal(){
cout<<"I'm an animal"<<endl;
}
Animal(int age){
this->age=age
cout<<"I'm "<<age<<" years old"<<endl;
}
void set(int age);
void Shout(){
cout<<"I'm shouting!"<<endl;
}
~Animal(){
cout<<"注销中。。。"<<endl;
}
};
#成员函数定义
void Animal::set(int age){
this->age=age;
}
#继承
class Dog : public Animal, public otherAnimal{ // 多继承
public:
void Shout(){
cout<<"I'm barking"<<endl;
}
}
#实例化
Dog d;
Dog d(3);
d.Shout();
#抽象
C++ 程序中，任何带有公有和私有成员的类都可以作为数据抽象的实例。
class Payment{
public:
int money;
void pay(int money){};
}
# 如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。纯虚函数是通过在声明中使用 "= 0" 来指定的
class Box
{
public:
// 纯虚函数
virtual double getVolume() = 0;
private:
double length; // 长度
double breadth; // 宽度
double height; // 高度
};
# 抽象类说明
class Shape
{
public:
double area() //求面积
{
//如何求??
}
}
实际上，只要是具体图形就有面积这个量，但是对”图形”求面积是没有任何意义的，只有在知道具体的图形类型之后才能求面积。所以对”图形”来说，area()函数无法实现，且不可让Shape生成对象(生成对象无意义)，
这就需要把Shape定义成一个抽象类：把area()函数声明为纯虚函数即可：
virtual double area() = 0;
结什么是抽象类：其实，在c++中并没有抽象类的概念，要实现抽象类则需要通过纯虚函数实现。纯虚函数指的是只定义函数原型的成员函数。在c++的类中，只要存在纯虚函数，那么该类就变成抽象类。
(1) 每个具体图形的求面积算法不一样，所以加上virtual关键字，表明该函数是虚函数，在子类中重写时可以发生多态；
(2) 为对Shape类求面积无意义，所以加上”= 0”表明该函数声明为纯虚函数，不需要定义函数体。
(3) 抽象类不能生成对象，只能用作父类被继承，子类必须实现纯虚函数的具体功能，在子类中，父类的纯虚函数被实现后就变成虚函数，当然，如果子类没有实现父类的纯虚函数，那么子类也是抽象类一个。
#接口
c++中接口也是一种特殊的类，需要满足：
(1) 类中没有定义任何成员变量
(2) 类中所有成员函数都是公有且都是纯虚函数
class deviceOp
{
public:
virtual bool OpenDev() = 0;
virtual void CloseDev() = 0;
virtual bool WriteDev(const char* buf, int len) = 0;
virtual int ReadDev(char* buf, int len) = 0;
};
接口是一种特殊的抽象类，所以抽象类具有只能被继承不能创建对象的特征它也具备。
https://www.cnblogs.com/xiaoxiaoji/p/9399283.html
浙公网安备 33010602011771号