java 视频 (4) 总结

class Person
{
private int age=100;//当age 前边有private 修饰的时候，只可以在本类中被访问，如果在其他的类中为成员变量赋值，会发生错误
private String name="unknown";
void shout()
{
//int age=10;//类的成员变量 ,使用对象为成员变量定义值，在函数里调用，如果函数里定义了局部变量，那么调用的是局部变量
System.out.println(name+"'s age is"+age);//类的成员函数
}

public Person()
{
System.out.println("the construct is calling");
age=100;//在在构造函数里初始化对象，对象一产生就会调用构造函数，就会调用其中的函数和初始话成员变量.

}
//当系统里自己定义了有参数的构造函数时，系统就不会再帮着定义无参的构造函数了，所以需要使用无参的函数时还是要自己定义;

/*public Person()
{
此构造函数什么也不做，当没有手动建立构造函数时，系统会自己建立这样的一个构造函数
}
*/

public Person(String x)
{
name=x;

}

public Person(String name,int age)
{
this.name=name;//使用this 当参数里的名称和成员变量名一样的时候.
this.age=age;

}

public void func1()
{
System.out.println(name) ;
}
public void func2()
{
Person a2=new Person("a2");
a2.func1();
this.func1();//代表a1 这个对象调用func1,也可以直接调用func1 因为在同一个类中，又是public 的，调用另一个函数是可以的
}

public static void main(String args[])//这个函数放在哪个类里，哪个类就先启动，这个函数肯在拿个类没关系
{
Person a1=new Person("a1");
a1.func2();
}

}

/*Person p1=new Person();
Person p2=new Person();
p1.age=90;
Person p3=new Person("zhangsan",45);
Person p4=new Person("wangwu");
p1.shout();
p2.shout();
p3.shout();
p4.shout();*/
/*p2 .age 自动初始化的值为0;
/p1.shout();
p2.shout();
String str1=new String("abc");
String str2=new String("abc");
String str3=str1;
if(str3==str2)//使用== 号是指这个变量的引用的值，当使用new 之后就会分配两个堆内存，同时还有栈内存，这两个栈内存str1,str2 的内容肯定是不同的,所以使用==得到的是不同的值而使用equals 是指变量引用的内容!
if(str3.equals(str2))//而equals () 所有对象都有这个方法，他指的是对象的内容，也就是堆对象的内容，因为都是abc 所以其内容是相同的！
{
System.out.println("it is true");
}

else
System.out.println("it is false");

new Person().shout();//在main 函数里使用一个匿名对象，可以调用方法，这个对象只使用一次，以后再也不用 了！！
//getPerson(new Person());//使用匿名对象，试验方法。

}

public int getAge()
{

return age;

}

public void setAge(int x)
{
if(age<0)
return ;
age=x;
}

public static void getPerson(Person p)
{
p.shout();

}
*/

/* public static void main(String args[])//这个函数放在哪个类里，哪个类就先启动，这个函数肯在拿个类没关系
{
Person p1=new Person();
Person p2=new Person();
p1.age=90;
//p2 .age 自动初始化的值为0;
p1.shout();
p2.shout();
String str1=new String("abc");
String str2=new String("abc");
String str3=str1;
//if(str3==str2)//使用== 号是指这个变量的引用的值，当使用new 之后就会分配两个堆内存，同时还有栈内存，这两个栈内存str1,str2 的内容肯定是不同的,所以使用==得到的是不同的值而使用equals 是指变量引用的内容!
if(str3.equals(str2))//而equals () 所有对象都有这个方法，他指的是对象的内容，也就是堆对象的内容，因为都是abc 所以其内容是相同的！
{
System.out.println("it is true");
}

else
System.out.println("it is false");

new Person().shout();//在main 函数里使用一个匿名对象，可以调用方法，这个对象只使用一次，以后再也不用 了！！
getPerson(new Person());//使用匿名对象，试验方法。

}

*/

/* class TestPerson {

public static void main(String args[])//这个函数放在哪个类里，哪个类就先启动，这个函数肯在拿个类没关系
{
Person p1=new Person();
Person p2=new Person();
//p1.age=90;
//p2 .age 自动初始化的值为0;
p1.shout();
p2.shout();
String str1=new String("abc");
String str2=new String("abc");
String str3=str1;
//if(str3==str2)//使用== 号是指这个变量的引用的值，当使用new 之后就会分配两个堆内存，同时还有栈内存，这两个栈内存str1,str2 的内容肯定是不同的,所以使用==得到的是不同的值而使用equals 是指变量引用的内容!
if(str3.equals(str2))//而equals () 所有对象都有这个方法，他指的是对象的内容，也就是堆对象的内容，因为都是abc 所以其内容是相同的！
{
System.out.println("it is true");
}

else
System.out.println("it is false");

}

}
*/
class Person
{
private int age=100;//当age 前边有private 修饰的时候，只可以在本类中被访问，如果在其他的类中为成员变量赋值，会发生错误
private String name="unknown";
void shout()
{
//int age=10;//类的成员变量 ,使用对象为成员变量定义值，在函数里调用，如果函数里定义了局部变量，那么调用的是局部变量
System.out.println(name+"'s age is"+age);//类的成员函数
}

public Person()
{
System.out.println("the construct is calling");
age=100;//在在构造函数里初始化对象，对象一产生就会调用构造函数，就会调用其中的函数和初始话成员变量.

}
//当系统里自己定义了有参数的构造函数时，系统就不会再帮着定义无参的构造函数了，所以需要使用无参的函数时还是要自己定义;

/*public Person()
{
此构造函数什么也不做，当没有手动建立构造函数时，系统会自己建立这样的一个构造函数
}
*/

public Person(String x)
{
name=x;

}

public Person(String name,int age)
{
this.name=name;//使用this 当参数里的名称和成员变量名一样的时候.
this.age=age;

}

public void func1()
{
System.out.println(name) ;
}
public void func2()
{
Person a2=new Person("a2");
a2.func1();
this.func1();//代表a1 这个对象调用func1,也可以直接调用func1 因为在同一个类中，又是public 的，调用另一个函数是可以的
}

public static void main(String args[])//这个函数放在哪个类里，哪个类就先启动，这个函数肯在拿个类没关系
{
Person a1=new Person("a1");
a1.func2();
}

}

/*Person p1=new Person();
Person p2=new Person();
p1.age=90;
Person p3=new Person("zhangsan",45);
Person p4=new Person("wangwu");
p1.shout();
p2.shout();
p3.shout();
p4.shout();*/
/*p2 .age 自动初始化的值为0;
/p1.shout();
p2.shout();
String str1=new String("abc");
String str2=new String("abc");
String str3=str1;
if(str3==str2)//使用== 号是指这个变量的引用的值，当使用new 之后就会分配两个堆内存，同时还有栈内存，这两个栈内存str1,str2 的内容肯定是不同的,所以使用==得到的是不同的值而使用equals 是指变量引用的内容!
if(str3.equals(str2))//而equals () 所有对象都有这个方法，他指的是对象的内容，也就是堆对象的内容，因为都是abc 所以其内容是相同的！
{
System.out.println("it is true");
}

else
System.out.println("it is false");

new Person().shout();//在main 函数里使用一个匿名对象，可以调用方法，这个对象只使用一次，以后再也不用 了！！
//getPerson(new Person());//使用匿名对象，试验方法。

}

public int getAge()
{

return age;

}

public void setAge(int x)
{
if(age<0)
return ;
age=x;
}

public static void getPerson(Person p)
{
p.shout();

}
*/

/* public static void main(String args[])//这个函数放在哪个类里，哪个类就先启动，这个函数肯在拿个类没关系
{
Person p1=new Person();
Person p2=new Person();
p1.age=90;
//p2 .age 自动初始化的值为0;
p1.shout();
p2.shout();
String str1=new String("abc");
String str2=new String("abc");
String str3=str1;
//if(str3==str2)//使用== 号是指这个变量的引用的值，当使用new 之后就会分配两个堆内存，同时还有栈内存，这两个栈内存str1,str2 的内容肯定是不同的,所以使用==得到的是不同的值而使用equals 是指变量引用的内容!
if(str3.equals(str2))//而equals () 所有对象都有这个方法，他指的是对象的内容，也就是堆对象的内容，因为都是abc 所以其内容是相同的！
{
System.out.println("it is true");
}

else
System.out.println("it is false");

new Person().shout();//在main 函数里使用一个匿名对象，可以调用方法，这个对象只使用一次，以后再也不用 了！！
getPerson(new Person());//使用匿名对象，试验方法。

}

*/

/* class TestPerson {

public static void main(String args[])//这个函数放在哪个类里，哪个类就先启动，这个函数肯在拿个类没关系
{
Person p1=new Person();
Person p2=new Person();
//p1.age=90;
//p2 .age 自动初始化的值为0;
p1.shout();
p2.shout();
String str1=new String("abc");
String str2=new String("abc");
String str3=str1;
//if(str3==str2)//使用== 号是指这个变量的引用的值，当使用new 之后就会分配两个堆内存，同时还有栈内存，这两个栈内存str1,str2 的内容肯定是不同的,所以使用==得到的是不同的值而使用equals 是指变量引用的内容!
if(str3.equals(str2))//而equals () 所有对象都有这个方法，他指的是对象的内容，也就是堆对象的内容，因为都是abc 所以其内容是相同的！
{
System.out.println("it is true");
}

else
System.out.println("it is false");

}

}
*/

本文出自 “Fighting” 博客，转载请与作者联系！