Please check if these two methods for inheritance and initialization are good or bad I am new to JavaScript.  I know that many inheritance and initialization methods have been written and use some advance features like Object.create:

Simple JavaScript Inheritance

Why Prototypal Inheritance Matters

For practice, I wrote my own methods for inheritance and initialization.  I have no idea if my code is good or if it could be improved.  Could someone help me and give me some advice?

function Class() {};

Class.prototype.create = function () {
    var constr = this.constructor; 
    var instance = new constr();

    for (var i = 0; i &lt; arguments.length; i++) {
        var props = arguments[i];
        for (var name in props){
            instance[name] = props[name];
        }
    }   

    return instance;
}

Class.prototype.extend = function () {
    var constr = this.constructor;
    var proto = this.constructor.prototype;

    function ProtoClas() {};

    var prototype = ProtoClas.prototype = (function (proto) {
        function F() {};
        F.prototype = proto;
        return new F();
    })(proto); 

    ProtoClas.prototype.constructor = ProtoClas;

    for (var i = 0; i &lt; arguments.length; i++) {
        var props = arguments[i];
        for (var name in props){
            prototype[name] = props[name];
        }
    }   

    return new ProtoClas();
}

Class.extend = function () {
    var args  = Array.prototype.slice.call(arguments);  
    return this.prototype.extend.apply(new this(), args);
}

Class.create = function () {
    var args  = Array.prototype.slice.call(arguments);  
    return this.this.prototype.create.apply(this, args);
}


I then generate a new Class and an instance through this Class:

var Person = Class.extend({
    say: function () {
        console.log("Hello");
    },
    walk: function () {
        console.log("walk");
    }
});

var person = Person.create({
    name:'lee'
})

console.log(Person);
console.log(person);
I'm the author of Why Prototypal Inheritance Matters. It's good that you're taking an interest in prototypal inheritance. So let's review your code. I'll start with your use case and then discuss the implementation.
The Use Case
var Person = Class.extend({
    say: function () {
        console.log(&quot;Hello&quot;);
    },
    walk: function () {
        console.log(&quot;walk&quot;);
    }
});

var person = Person.create({
    name:'lee'
});

console.log(Person);
console.log(person);

This code looks good. It's very similar to what I wrote in my aforementioned article. I would like to point out one thing though: you don't need two separate methods extend and create. Object creation and extension may be combined into a single function. Hence you could do:
var Person = Class.extend({
    say: function () {
        console.log(&quot;Hello&quot;);
    },
    walk: function () {
        console.log(&quot;walk&quot;);
    }
});

var person = Person.extend({
    name: &quot;lee&quot;
});

console.log(Person);
console.log(person);

The Implementation
Since you only require one method for prototypal inheritance I'll primarily focus on your extend function. First, your Class.extend method is needlessly complicated. I would rewrite it as:
function Class() {}

var extend = Class.prototype.extend = function () {
    //...
};

Class.extend = function () {
    return extend.apply(new Class, arguments);
};

As you can see you don't need to call Array.prototype.slice on arguments. It may be directly passed to apply. In addition try keeping things in variables as much as possible. Avoid expressions like this.prototype.extend. Also be explicit: write new Class instead of new this().

Your Class.prototype.extend function is not only confusing but also wrongly implemented. It doesn't extend the given object this. Instead it extends ProtoClas.prototype which is actually just Object.create. I would implement Class as follows:
function Factory() {}

var CLASS = {
    extend: function () {
        Factory.prototype = this;
        var instance = new Factory;
        var length = arguments.length;
        var index = 0;

        while (index &lt; length) {
            var prototype = arguments[index++];

            for (var property in prototype)
                if (instance[property] !== prototype[property])
                    Object.defineProperty(instance, property,
                        Object.getOwnPropertyDescriptor(prototype, property));
        }

        return instance;
    }
};

You may now use CLASS.extend as follows:
var PERSON = CLASS.extend({
    say: function () {
        console.log(&quot;Hello&quot;);
    },
    walk: function () {
        console.log(&quot;walk&quot;);
    }
});

var person = PERSON.extend({
    name: &quot;lee&quot;
});

console.log(PERSON);
console.log(person);

Note that instead of doing var instance = Object.create(this) I used a function called Factory instead. The reason for doing this is performance: Object.create creates a new constructor every time. Here I'm simply reusing a single Factory constructor.
In addition for each argument supplied to extend I copy all the properties of the argument to the instance only if it doesn't already exist. This check speeds up the process because every object inherits from Object.prototype and copying is a very expensive operation.
Also instead of copying the properties using instance[property] = prototype[property] I'm using Object.defineProperty and Object.getOwnPropertyDescriptor. The allows you to copy properties as is allowing you to use getters/setters, etc.
The Alternative
On a concluding note I would like to mention that true prototypal inheritance is slow in JavaScript because JavaScript favors the constructor pattern of prototypal inheritance instead. Hence if you wish to write fast code then I suggest you read the following article which describes prototype-class isomorphism: https://stackoverflow.com/a/17893663/783743