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

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

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

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

 

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

 

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

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

描述时：这些对象的共性有：姓名，年龄，性别，学习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();  

    }  

}