标签:
//Car.java
//对Car这类事物进行描述
class Car
{
//成员变量
String color = "YELLOW";
int num = 4;
//成员方法
void show()
{
//临时变量
int num = 10;
//输出临时变量的值
System. out.println("color = " +color +"...num = " +num);
}
}
class CarDemo
{
public static void main(String[] args)
{
//通过new关键字,建立对象
//c就是一个类类型的引用变量,指向了该类的对象
Car c = new Car();
//对对象的属性进行修改
c. color = "black" ;
//输出成员变量的默认值
System. out.println(c.num );
//通过对象.成员的形式来使用对象的功能
c.show();
}
}
Car c1 = new Car();
c1.colour="RED";
Car c2 = new Car();
Car.java
class Car
{
String color = "red";
int num = 4;
public static void run()
{
System. out.println("function run is running!" );
}
}
class CarDemo{
public static void main(String[] args){
//对对象方法仅进行一次调用时,就可以使用匿名对象
new Car().run();
//匿名对象可以作为实际参数进行传递
show(new Car());
}
public static void show(Car c){
c. num = 3;
c. color = "black" ;
System. out.println("function show is running!" );
System. out.println(c.num + "..." + c. color);
}
}
Person.java
/*
人:
属性:年龄
行为:说话
*/
class Person{
//private:私有,是一个权限修饰符,用于修饰
//不希望别人直接访问赋值,需要通过私有化把属性进行隐藏
private int age ;
//通过提供set、get公共方法对其访问
public void setAge( int a){
//在set方法内可以对属性的赋值进行限制
if (a > 0 && a < 130){
age = a;
} else
System. out .println("错误的数据" );
}
public int getAge(){
return age ;
}
void speak(){
System. out .println("age = " + age);
}
}
class PersonDemo{
public static void main(String[] args){
Person p = new Person();
//通过其他方式访问
p.setAge(20);
p.speak();
//赋值不合法,set方法就不允许成功赋值
p.setAge(-20);
}
}
1 Person.java
2
3 class Person{
4 private String name ;
5 private int age ;
6 //定义一个Person类的构造函数
7 //构造函数,而且是空参数的
8 Person(){
9 System. out.println("person run" );
10 }
11 public void speak(){
12 System. out.println(name + ":" + age);
13 }
14 }
15
16 class ConsDemo{
17 public static void main(String[] args){
18 //构造函数:构建创造对象时调用的函数
19 //作用:可以给对象进行初始化
20 Person p = new Person();
21 p.speak();
22 }
23 }
构造函数:对象创建时,会调用并且只调用一次。
一般函数:对象创建后,可以被调用多次。
Person.java
class Person{
private String name ;
private int age ;
Person(){
name = "baby" ;
age = 1;
System. out .println("person run" );
}
//如果有的孩子一出生就有名字
Person(String n){
name = n;
}
//如果有的孩子一出生就有名字和年龄
Person(String n, int a){
name = n;
age = a;
}
public void speak(){
System. out .println(name + ":" + age );
}
}
class ConsDemo{
public static void main(String[] args){
Person p1 = new Person();
p1.speak();
Person p2 = new Person("旺财" );
p2.speak();
Person p3 = new Person("小强" ,10);
p3.speak();
}
}
this关键字
Person.java
class Person{
private String name ;
private int age ;
Person(String name){
//通过this区分成员变量和局部变量
this.name = name;
}
Person(String name, int age){
//this也可以用于在构造函数中调用其他构造函数
//通过this在构造函数中调用其他构造函数的时候,只能定义在构造函数的第一行,因为初始化动作要先执行,否则就会报错。
this(name);
this.age = age;
}
public void speak(){
System. out .println(name + ":" + age );
}
}
class ConsDemo{
public static void main(String[] args){
Person p1 = new Person("旺财" );
p1.speak();
Person p2 = new Person("小强" ,10);
p2.speak();
}
}
this应用实例
Person.java
class Person{
private String name ;
private int age ;
Person(String name, int age){
this.name = name;
this.age = age;
}
/*判断是否是同龄人*/
public boolean compare(Person p){
return this .age == p.age;
}
}
class ConsDemo{
public static void main(String[] args){
Person p1 = new Person("旺财" ,10);
Person p2 = new Person("小强" ,10);
System.out.println(p1.compare(p2));
}
}
Person.java
class Person{
//成员变量,实例变量
String name;
//静态变量,类变量
//所有对象共享的属性用static修饰
static String country = "CN";
public void show(){
System. out.println(country + ":" + name);
//等效语句:System.out.println(Person.country + ":" + this.name);
}
}
class StaticDemo{
public static void main(String[] args){
Person p = new Person();
System. out.println(p.country);
//可以用类名直接调用
System. out.println(Person.country);
}
}
成员变量和静态变量的区别?
Person.java
class Person{
String name;
static String country = "CN";
//静态方法
public static void show(){
System. out.println(country + ":" + name);
}
}
MainDemo.java
class MainDemo{
public static void main(String[] args){
for(int x = 0; x < args.length; x++){
System. out.println(args[x]);
}
}
}
静态什么时候用?
①静态变量
当分析对象中所具备的该成员变量值都是相同时,这时这个成员变量就可以被静态修饰。
只要数据在对象中的値都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的。
如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的。
②静态函数
函数是否用静态修饰,就参考一点,就是该函数功能是否需要访问到对象中的特有数据。
简单点说,从源代码看,该功能是否需要访问非静态的成员变量,如果需要,该功能就是非静态的。
如果不需要,就可以将该功能定义成静态的。当然,也可以定义成非静态,但是非静态需要被对象调用。
如果没有访问特有数据的方法,该对象的创建是没有意义。
Demo.java
class Demo{
int age ;
static int num = 9;
public static void speak(){
System. out.println(num);
}
public void show(){
System. out.println(age );
}
}
class StaticDemo{
public static void main(String[] args){
Demo.speak();
new Demo().show();
}
}
StaticCode.java
class StaticCode{
static int num;
static{
num = 10;
}
static void show(){
System. out.println(num);
}
}
class StaticCodeDemo{
public static void main(String[] args){
StaticCode.show();
}
}
Person.java
class Person{
private String name ;
//构造代码块,可以给所有对象进行初始化的
{
System. out.println("person run" );
}
//是给对应的对象进行针对性的初始化
Person(){
name = "baby" ;
}
Person(String name){
this.name = name;
}
public void speak(){
System. out.println("name:" + name);
}
}
class StaticCodeDemo{
public static void main(String[] args){
Person p1 = new Person();
p1.speak();
Person p2 = new Person("旺财" );
p2.speak();
}
}
注意:
构造代码块是用于给对象统一初始化。对象一建立就运行,而且优先于构造函数运行。
而构造函数是给对应对象初始化。
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
标签:
原文地址:http://www.cnblogs.com/tozr/p/4182563.html