java（五）【面向对象】匿名对象、封装、构造函数

面向对象定义：

面向对象是相对面向过程而言

面向对象和面向过程是一种思想

面向过程：强调的是功能行为

面向对象：将功能封装进对象，强调具备了功能的对象

面向对象是基于面向过程的

面向对象三大特征：封装、继承、多态

类和对象的关系

类就：是对现实生活中事务的描述

对象：是这类事物，实实在在存在个体

实例：

//需求：描述汽车（颜色、轮胎数），描述事物其实就是在描述事物的属性和方法
//属性对应是类中变量，行为对应的类中的函数（方法）
//其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员（成员变量，成员方法）
class car
{
    String color ="red"; //描述颜色
    int num =4; //描述轮胎数
    //运行行为
    void run()
    {
        System.out.println(color+"..."+num);
    }
    }
public class asd {
    public static void main(String[] args) {
    //生产汽车，在java中通过new操作符来完成
    //其实就是在堆内存中产生一个实体
        car c = new car(); //c就是一个类类型变量。记住：类类型变量指向对象
        //需求：将已有车的颜色改成蓝色。指挥该对象使用，在java指挥方式为：对象.对象成员
        c.color ="blue";
        c.run();
        car c1 =new car();
        c1.run();
    }    
}
结果为：

blue...4
red...4

 成员变量和局部变量

class car
{
    String color ="red"; //color成员变量
    int num =4; //num成员变量
    void run()
    {
        System.out.println(color+"..."+num);
    }
    }

作用范围：

1. 成员变量作用于整个类中
2. 局部变量作用与函数中或者语句中

在内存中的位置：

1. 成员变量：在堆内存中，因为对象的存在，才在内存中存在。
2. 局部变量：存在栈内存中

 匿名对象

定义：是对象的简化形式

两种使用情况：

1. 当对对象方法仅进行一次调用的时候
2. 匿名对象可以作为实际参数进行传递

class car
{
    String color ="red"; 
    int num =4; 
    void run()
    {
        System.out.println(color+"..."+num);
    }
    }
public class asd {
    public static void main(String[] args) {
    //car c =new car();   第一种方式
    //show(c);
        show (new car());//匿名对象；   第二种方式，效果一致。
    }    
    public static void show (car c)
    {
        c.num=7;
        c.color="green";
        c.run();
    }
}

 封装

定义：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：

1. 将变化隔离
2. 便于使用
3. 提高重用性
4. 提高安全性

封装原则：

1. 将不需要对外提供的内容都隐藏起来
2. 把属性都隐藏，提供公共方法对其访问

 private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）

  私有只在本类中有效

私有仅仅是封装的一种表现形式

//之所以对外提供访问方式，是因为可以在访问方式中加入逻辑判断语句
class person
{
    private int age;  //一个属性有两个方法，一个set，一个get
    public void setAge(int a)
    {
        if(a>0 && a<130){
            age=a;
            speak();
    }else {
            System.out.println("nono");
        }
}
    
    public int getAge()
    {
        return age;
    }
    void  speak()
    {
        System.out.println("age="+age);
    }
    }
public class asd {
    public static void main(String[] args) {
    person p = new person();
    //p.age=-20;
    p.setAge(-20);
    //p.speak();
    }
    }

 

构造函数

特点：

1. 函数名与类名相同
2. 不用定义返回值类型
3. 不可以写return语句

作用：给对象进行初始化

注意：

1. 默认构造函数的特点
2. 多个构造函数时以重载的形式存在的

构造函数和一般函数的区别

1. 在写法上有不同。
2. 在运行上也有不同。
3. 构造函数时在对象一建立就允许，给对象初始化
4. 而一般方法是对象调用才执行，是给对象添加对象具备的功能。
5. 一个对象建立，构造函数只运行一次
6. 而一般方法可以被该对象调用多次

什么时候定义构造函数呢？

　　当分析事物时，该事物具备一些特征或者行为，那么将这些内容定义在构造函数中

//对象一建立就会调用与之对应的构造函数
//当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数
//当在类中自定义了构造函数后，默认的构造函数就没有了
class person
{
    private String name;
    private int age;
    person(){
        System.out.println("name="+name+",age="+age);
        cry();
    }
    person (String n)
    {
        name=n;
        System.out.println("name="+name+",age="+age);
        cry();
    }
    public void setName (String n)
    {
        name =n;
    }
    public String getName()
    {
        return name;
    }
    person(String n,int a)
    {
        name =n;
        age =a;
        System.out.println("name="+name+",age="+age);
        cry();
    }
    public static void cry()
    {
        System.out.println("cry");
    }
    }
public class asd {
    public static void main(String[] args) {
    //person p = new person();
    person p2 = new person("lili");
    p2.setName("qweqwe");   //修改name
    System.out.println(p2.getName());
    //person p3 = new person("lolo",10);
    }
    }

构造代码块

作用 ：给对象进行初始化

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

和构造函数的区别：

1. 构造代码块是给所有对象进行统一初始化
2. 构造函数时给对应的对象初始化

构造代码块中定义的是不同对象共性的初始化内容