public class CaptureConversion {
static void f1(Holder holder){
T holderT = holder.getT();
System.out.println(holderT.getClass().getSimpleName());
}
static void f2(Holder> holder){
f1(holder);
//捕获类型
}
public static void main(String[] args) {
Holder holder=new Holder<>(1);
f1(holder);
f2(holder);
Holder holder1=new Holder();
holder1.setT(new Object());
f2(holder1);
Holder holder2=new Holder<>(1.0d);
f2(holder2);
}
}
//运行结果为
Integer
Integer
Object
Double
public class ListOfInt {
public static void main(String[] args) {
List list=new ArrayList<>();
for (int i = 0; i < 5; i++) {
list.add(i);
}
for (int i:list) {
System.out.println(i);
}
}
}
//运行结果为
0 1 2 3 4
public class ByteSet {
Byte [] possible={1,2,3,4,5,6,7,8,9};
Set byteSet =new HashSet<>(Arrays.asList(possible));
//but you can't do this 但是你做不到
//Set bytes=new HashSet<>(Arrays.asList(1,2,3,4,5,6,7,8,9));
}
public class Farray {
static T[] fill(T[] t,Generator generator){
for (int i = 0; i < t.length; i++) {
t[i]=generator.next();
}
return t;
}
}
interface RandomGenericator extends Generator{}
class PrimitiveGenericTest{
public static void main(String[] args) {
String[] strings = Farray.fill(new String[7], new RandomGenericator() {
@Override
public String next() {
StringBuffer sb = new StringBuffer();
String[] strs = {"a", "b", "c", "d", "e", "f", "g"};
Random random = new Random();
//随机生成四位随机数
for (int i = 0; i < 4; i++) {
sb.append(strs[random.nextInt(strs.length)]);
}
return sb.toString();
}
});
//打印 数组内容
for (String s :strings) {
System.out.println(s);
}
Integer[] fill = Farray.fill(new Integer[7], new RandomGenericator() {
@Override
public Integer next() {
StringBuffer sb = new StringBuffer();
Random random = new Random();
for (int i = 0; i < 4; i++) {
sb.append(random.nextInt(10));
}
return Integer.valueOf(sb.toString());
}
});
for (int i:fill) {
System.out.println(i);
}
}
}
//运行结果为
fbdg
daed
bdee
eadg
bfgf
bgbc
ggdf
3456
4645
2447
8682
6451
3490
6290
public interface Payable {}
class Employee1 implements Payable{}
//class Hourly1 extends Employee1 implements Payable{}
public class FinxedSizeStack {
private int index = 0;
private Object[] array;
public FinxedSizeStack(int size) {
array = new Object[size];
}
public void push(T item) {
array[index++] = item;
}
public T pop(){
return (T) array[--index];
}
}
class Demo{
public static void main(String[] args) {
FinxedSizeStack stack = new FinxedSizeStack<>(5);
for (String s:"A B C D E".split(" ")) {
stack.push(s);
}
for (int i = 0; i < 5; i++) {
System.out.print(stack.pop() +" ");
}
}
}
//运行结果为
E D C B A
public class UseList {
void f(List ws){}
void f(List ts){}
}
public class UseList {
void f1(List ws){}
void f2(List ts){}
}
public class ComparablePet implements Comparable{
@Override
public int compareTo(ComparablePet o) {
return 0;
}
}
class SelfBounded>{//...}
class GenericType{}
class CuriouslyRecurringGeneric extends GenericType{}
class BasicHolder{
T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
void f(){
System.out.println(t.getClass().getSimpleName());
}
}
class Subtype extends BasicHolder {}
class CRGWithBasicHolder {
public static void main(String[] args) {
Subtype subtype = new Subtype();
Subtype subtype1 = new Subtype();
subtype.setT(subtype1);
Subtype subtype2 = subtype.getT();
subtype.f();
}
}
//运行结果为
Subtype
class Other{}
class BasicOther extends BasicHolder{}
class Unconstrained{
public static void main(String[] args) {
BasicOther basicOther=new BasicOther();
basicOther.setT(new Other());
BasicOther basicOther1=new BasicOther();
Other other = basicOther.getT();
basicOther.f();
}
}
//运行结果为
Other
public class SelfBounded> {
T t;
public T getT() {
return t;
}
public SelfBounded setT(T t) {
this.t = t;
return this;
}
}
class A extends SelfBounded {}
//还可以
class B extends SelfBounded {}
class C extends SelfBounded {
C setAndGet(C args) {
setT(args);
return getT();
}
}
class D {
}
//做不到
// !class E extends SelfBounded {}
//编译错误类型参数D不在其范围内
//您可以这样做,所以您不能强迫惯用用法
class F extends SelfBounded {}
class SelfBounding {
public static void main(String[] args) {
A a = new A();
a.setT(new A());
a=a.setT(new A()).getT();
a=a.getT();
C c=new C();
c.setAndGet(new C());
}
}
class A extends SelfBounded{}
class NoSelfBounded{
T t;
public T getT() {
return t;
}
public NoSelfBounded setT(T t) {
this.t = t;
return this;
}
}
class A2 extends NoSelfBounded{}
class B2 extends NoSelfBounded{}
class C2 extends NoSelfBounded{
C2 setAndGet(C2 arg){
setT(arg);
return getT();
}
}
class D2 {}
//现在可以了
class E2 extends NoSelfBounded{}
class SelfBoundingMethods{
static > T f(T t){
return t.setT(t).getT();
}
public static void main(String[] args) {
A a=f(new A());
}
}
public class Base {
}
class Derived extends Base {
}
interface OrdinaryGetter {
Base get();
}
interface DerivedGetter extends OrdinaryGetter {
//重写方法的返回类型允许
@Override
Derived get();
}
class CovariantReturnTypes{
void test(DerivedGetter derivedGetter){
Derived derived = derivedGetter.get();
}
}
interface GenericGetter>{
T get();
}
interface Getter extends GenericGetter{}
class GenericsAndReturnTypes{
void test(Getter getter){
Getter result = getter.get();
//也是基本类型
GenericGetter gg = getter.get();
}
}
class OrdinarySetter{
void set(Base base){
System.out.println("OrdinarySetter set Base");
}
}
class DerivedSetter extends OrdinarySetter{
void set(Derived derived){
System.out.println("DerivedSetter set Derived");
}
}
class OrdinaryArguments{
public static void main(String[] args) {
Base base=new Base();
Derived derived=new Derived();
DerivedSetter derivedSetter=new DerivedSetter();
derivedSetter.set(derived);
derivedSetter.set(base);
//编译重载而不是覆盖
}
}
//运行结果为
DerivedSetter set Derived
OrdinarySetter set Base
interface SelfBoundSetter>{
void set(T t);
}
interface Setter extends SelfBoundSetter{}
class SelfBoundingAndCovariantArguments{
void testA(Setter setter,Setter setter2,SelfBoundSetter selfBoundSetter){
setter.set(setter2);
//setter.set(selfBoundSetter); error
//selfBoundSetter.set(Setter); 在 SelfBoundSetter
//不适用于(SelfBoundSetter)
}
}
class GenericSetter{
void set(T t){
System.out.println("GenericSetter set t");
}
}
class DerivedGS extends GenericSetter {
void set(Derived derived){
System.out.println("DerivedGS set Derived");
}
}
class PlainGenericInheritance{
public static void main(String[] args) {
Base base=new Base();
Derived derived=new Derived();
DerivedGS derivedGS=new DerivedGS();
derivedGS.set(derived);
derivedGS.set(base);
}
}
//运行结果为
DerivedGS set Derived
GenericSetter set t