黑马程序员_Java基础_面向对象

来源：互联网发布：网络填表信息采集编辑：程序博客网时间：2024/04/28 23:50

一、面向对象（类和对象的关系）

面向对象的三个特征：封装，继承，多态。

以后开发：找对象，建立对象，使用对象，维护对象的关系。

类和对象的关系：类是对象的抽象，对象是类的具体实现。

现实生活中的对象：张三，李四。

描述：提取对象中的共性内容。对具体的抽象。

描述时：这些对象的共性有：姓名，年龄，性别，学习java功能。

映射到java中，描述就是class定义的类。

集体对象就是对应java在堆内存中用new建立的实体。

类就是对现实生活中事物的描述。

对象就是这类事物，实实在在存在的个体。

[java] view plaincopy
/* 
定义一个简单的汽车类 
*/  
  
class Car  
{  
    String color="蓝色";//定义颜色  
    String name="奔驰";//定义品牌  
    int num=4;//定义轮胎数  
      
  
    void run()  
    {  
        System.out.println("品牌："+name+"\n颜色:"+color+"\n轮胎数："+num);  
    }  
}  
  
class  CarDemo  
{  
    public static void main(String[] args)   
    {  
        Car c=new Car();//在堆中产生一个实体（汽车）。在栈中产生Car类型c变量并指向实体。  
        c.color="红色";//更改对象c的color属性的值为"红色"。  
        c.run();//调用对象c的run()方法。  
    }  
}  

二、面向对象（成员变量和局部变量）

作用范围：

成员变量作用于整个类中，局部变量作用于函数中或者语句中。

成员变量：在堆内存中，因为对象的存在，才在内存中存在。

局部变量：在栈内存中。

三、面向对象（匿名对象）

例如：

new Car().num=5;

new Car.run();

这样并没有指明对象的名称（也就是引用）。

匿名对象使用方式1：当对象的方法值调用一次，可以用匿名对象，这样比较简化。

如果对一个对象进行多个成员调用，必须给这个对象起名字。

匿名对象使用方式2：可以将匿名对象作为实际参数进行传递。

四、面向对象（封装）

概念：是隐藏对象的属性和方法的实现细节。

[java] view plaincopy
/* 
Private访问修饰符 
*/  
class Person  
{  
    private String name="杨成";  
    private int age=18;  
      
    public void setAge(int a)//设置age函数  
    {  
        if(a>0&&a<300)  
        {  
            age=a;  
        }  
        else  
            System.out.println("修改年龄错误！");  
    }  
    public int getAge()//获得age  
    {  
        return age;  
    }  
    void display()//没写修饰符，表示默认。可以被同包不同类访问。  
    {  
        System.out.println("name:"+name+"\nage:"+getAge());  
    }  
}  
class PersonDemo  
{  
    public static void main(String[] args)   
    {  
        Person p=new Person();  
  
        //p.age=30;  //不能在Person类外访问其私有成员属性  
        p.setAge(21);  
        p.display();   
  
    }  
}  

五、面向对象（构造函数）

作用：用来初始化对象的成员变量。

注意：

1. 与类名同名

2. 没有返回值类型

3. 不可写return语句

提醒：同名构造函数通过形参的类型和形参的数目进行区分。

当一个类中没有定义构造函数时，系统会默认向类加入一个空参数的构造函数。

构造函数是在对象已建立就运行，给对象初始化。而类里面的一般函数是对象经过调用执行的。

一个对象建立构造函数只执行一次。而里面的一般函数可被该对象调用多次。

[java] view plaincopy
/* 
构造函数 
*/  
class Person  
{  
    private String name="杨成";  
    private int age=18;  
      
    Person()//不带参数构造函数  
    {  
        System.out.println("不带参数构造函数\n"+"name:"+name+"\nage:"+age);  
    }  
  
    Person(String n)// 带一个参数构造函数  
    {  
        name=n;  
        System.out.println("带一个参数构造函数\n"+"name:"+name+"\nage:"+age);  
    }  
    Person(String n,int a)// 带两个参数构造函数  
    {  
        name=n;  
        age=a;  
        System.out.println("带两个参数构造函数\n"+"name:"+name+"\nage:"+age);  
    }  
    void display()  
    {  
        System.out.println("name:"+name+"\nage:"+age);  
    }  
}  
class PersonDemo  
{  
    public static void main(String[] args)   
    {  
        Person p1=new Person();//采用不带参数构造函数初始化  
        Person p2=new Person("张三");//采用带一个参数构造函数初始化  
        Person p3=new Person("张三",22);//采用带两个参数构造函数初始化  
  
        //p.age=30;  //不能在Person类外访问其私有成员属性  
        //System.out.println();//换行  
        p1.display();   
        p2.display();  
        p3.display();  
  
    }  
}  

六、面向对象（构造代码块）

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象分别初始化。

[java] view plaincopy
/* 
构造代码块 
*/  
class Person  
{  
    private String name="杨成";  
    private int age=18;  
  
    {  
        System.out.println("构造代码块。");  
    }  
      
    Person()  
    {  
        System.out.println("不带参数构造函数\n"+"name:"+name+"\nage:"+age);  
    }  
  
    Person(String n)  
    {  
        name=n;  
        System.out.println("带一个参数构造函数\n"+"name:"+name+"\nage:"+age);  
    }  
    Person(String n,int a)  
    {  
        name=n;  
        age=a;  
        System.out.println("带两个参数构造函数\n"+"name:"+name+"\nage:"+age);  
    }  
    void display()  
    {  
        System.out.println("name:"+name+"\nage:"+age);  
    }  
}  
class PersonDemo  
{  
    public static void main(String[] args)   
    {  
        Person p1=new Person();//采用不带参数构造函数初始化  
        Person p2=new Person("张三");//采用带一个参数构造函数初始化  
        Person p3=new Person("李四",23);//采用带两个参数构造函数初始化  
        System.out.println();//换行  
        p1.display();   
        p2.display();  
        p3.display();  
  
    }  
}  

七、面向对象（this关键字）

this就是本类的对象，用来区分同名变量的。

[java] view plaincopy
/* 
this关键字 
*/  
class Person  
{  
    private String name="杨成";  
    private int age=18;  
  
    Person(String name)  
    {  
        this.name=name;//出现同名name，用this指定本类对象。  
        System.out.println("带一个参数构造函数\n"+"name:"+this.name+"\nage:"+this.age);  
    }  
    Person(String name,int age)  
    {  
        this.name=name;//出现同名name，用this指定本类对象  
        this.age=age;//出现同名age，用this指定本类对象  
        System.out.println("带两个参数构造函数\n"+"name:"+this.name+"\nage:"+this.age);  
    }  
    void display()  
    {  
        System.out.println("name:"+name+"\nage:"+age);  
    }  
}  
class PersonDemo  
{  
    public static void main(String[] args)   
    {  
        Person p1=new Person("张三");//采用带一个参数构造函数初始化  
        Person p2=new Person("李四",22);//采用带两个参数构造函数初始化  
      
        System.out.println();//换行  
        p1.display();   
        p2.display();  
    }  
}  

八、面向对象（this关键字的应用）

[java] view plaincopy
/* 
给人定义一个用于比较年龄是否相同的功能。 
*/  
public boolean compare(Person p)//判断功能代码  
{  
    return this.age==p.age;/*先逻辑判断，在返回逻辑值。 
                            this.age表示本类的age, 
                            p.age表示传递其它对象的age. 
 
                           */  
}  

九、面向对象（this关键字在构造函数间调用）

this语句用于构造函数之间进行互相调用。

this语句只能定义在构造函数的第一行。因为初始化要先执行。

[java] view plaincopy
/* 
this关键字在构造函数间的调用 
*/  
class Person  
{  
    private String name;  
    private int age;  
  
    Person()  
    {  
          
    }  
    Person(String name)  
    {  
        this();  
        this.name=name;  
    }  
    Person(String name,int age)  
    {  
        this(name);  
        this.age=age;  
    }  
    public void display()  
    {  
        System.out.println("name:"+this.name+"\nage:"+this.age);  
    }  
}  
class PersonDemo  
{  
    public static void main(String[] args)  
    {  
        Person p=new Person("李四",30);  
        p.display();  
    }  
}  

0 0