In Lambda calculus, are there two terms said A, B which are typeable but when they combine, they become not typeable? I have also provided my own examples and I am wondering if  they are correct.
Example 1: $A = x$ and $B = x$, they are both typeable but $A B = x x$ which are not typeable(?) 
Example 2: $A = \lambda x.x$ and $B = x$ so they are both typeable but $A B = \lambda x.x x$ which are not typeable (?)
Can you answer me whether are my answers correct and are there any other examples out there that fulfill the constraints above? 
 A: Yes, this is possible. 
Your example 1 is correct, and all the standard examples of untypeable terms eventually boil down to this kind of self-application.
Your example 2 is incorrect. $A = \lambda x.x$ will have a function type $\sigma \to \sigma$, and combined with a suitable term $B = x$ of type $\sigma$ yields the application term $(\lambda x.x)x$ with type $\sigma$. Because note that $AB = (\lambda x.x)(x)$, not $\lambda x. (xx)$.  
The general pattern is that type assignment fails when running into loops, when a type wants to be assigned in terms of itself. In the example of , the whole term will have some type $\rho$; and since it is an application term, the functor $x$ must have a function type with input  and output $\rho$; that is, : $\sigma = \tau \to \rho$. But the input to this function is  again, so the type of the input must be the same as the type of the functor itself: We have =, and hence : $\sigma = \sigma \to \rho$. The fact that  occurs on the right-hand side of the equation is precisely the problem. Attempting to assign a simple type to $x$ in this occurrence context will trigger an infinite loop, so $xx$ is not typeable, and neither is any term that contains, or beta-reduces to a term that contains, $xx$ as a subterm. All untypeable terms will have this pattern, where in the type equation =...,  occurs again on the right-hand side. 
You may want to look into the type assignment algorithm, which has rules to perform certain manipulations on these kinds of type equations. The algorithm will either terminate with a suitable type, if the term is typeable, or with $\mathrm{fail}$, if the term is not typeable, which happens precisely when this sort of loop-structure type assignment is encountered. For the details see e.g. H. Barendregt (1992), Lambda calculi with types, ch. 4.4.
