【ブロックチェーン　プログラミング】solidity contract クラスと同じと思え！

pragma solidity >= 0.4.0 < 0.7.0;
	contract testContract { 
}

contract objectA {
  // 実装内容・・・
}
contract objectB is objectA {
  // 実装内容・・・
}

contract objectA {
  // 実装内容・・・
}
contract objectB is objectA {
  // 実装内容・・・
}
contract objectC is objectA {
  // 実装内容・・・
}

contract objectA {
  // 実装内容・・・
}
contract objectB is objectA {
  // 実装内容・・・
}
contract objectC is objectB {
  // 実装内容・・・
}

contract objectA {
  // 実装内容・・・
}
contract objectB is objectA {
  // 実装内容・・・
}
contract objectC is objectA {
  // 実装内容・・・
}
contract objectD is objectA, objectB, objectC {
  // 実装内容・・・
}

pragma solidity >=0.4.16 <0.9.0;

//抽象contractでは、メソッドの型のみ宣言する
contract AbstractContract {
   function getValue() public view returns(uint);
}

//実態側で抽象contractを継承し、指定されたメソッドの実態を作成する
contract Calculator_implementation is AbstractContract {
 
   function getValue() public view returns(uint) {
      uint calcObjA = 10;
      uint calcObjB = 20;
      uint retValue = calcObjA ＊ calcObjB;
      return retValue;
   }
}

pragma solidity ^0.8.0;

interface Calculator {
   function getResult() external view returns(uint);
}
//インターフェースを継承
contract Calculator_implementation is Calculator {
//インターフェースで宣言されたメソッドの実態を実装する
   function getResult() external view returns(uint){

      uint calcObjA = 100; 
      uint calcObjB = 5;
      uint result = a % b;
      return result;

   }
}

//https://github.com/Arachnid/solidity-stringutils/blob/master/src/strings.sol のソースから
//抜粋
pragma solidity ^0.8.0;

//libraryキーワードを使用して、ライブラリであることを宣言

library strings {
    struct slice {
        uint _len;
        uint _ptr;
    }

    function memcpy(uint dest, uint src, uint len) private pure {
        // Copy word-length chunks while possible
        for(; len >= 32; len -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = type(uint).max;
        if (len > 0) {
            mask = 256 ** (32 - len) - 1;
        }
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }
    }
//以下省略

pragma solidity ^0.8.0;

import 'ds-test/test.sol';
//ライブラリをインポート
import './strings.sol';

contract StringsTest is DSTest {
//利用したいデータに対して、指定する、今回は全て
	using strings for *;


    function abs(int x) private pure returns (int) {
        if(x < 0)
            return -x;
        return x;
    }

    function sign(int x) private pure returns (int) {
        return x == 0 ? int(0) : (x < 0 ? -1 : int(1));
    }

    function assertEq0(string memory a, string memory b) internal {
        assertEq0(bytes(a), bytes(b));
    }

    function assertEq0(strings.slice memory a, strings.slice memory b) internal {
    	assertEq0(a.toString(), b.toString());
    }

    function assertEq0(strings.slice memory a, string memory b) internal {
        assertEq0(a.toString(), b);
    }

	function testSliceToString() public {
		string memory test = "Hello, world!";
		assertEq0(test, test.toSlice().toString());
	}

    function testBytes32Len() public {
        bytes32 test;
        for(uint i = 0; i <= 32; i++) {
            assertEq(i, test.len());
            test = bytes32((uint(test) / 0x100) | 0x2000000000000000000000000000000000000000000000000000000000000000);
        }
    }
//以下省略