Java基础（5）--类和对象

Java基础（5）--类和对象
5.1 面向对象概念
5.2 类与对象的关系
5.3 封装
5.4 构造函数
5.5 this关键字
5.6 static 关键字
5.7 单例设计模式

 

5.1 面向对象概念--一种思想
1.面向过程：强调过程。
  面向对象：强调具体事务。
2. 面向对象的特点：
   a.符合人们思考习惯的一种思想。
   b.可以将复杂的事情简单化
   c.将执行者变成指挥者
3. 面向对象开发过程：创建对象、使用对象、指挥对象做事情。
   面向对象设计过程：管理和维护对象之间的关系。
   面向对象的特征：封装encapsulation、继承inheritance、多态polymorphism。
4. 类：对事物的描述。对共性内容的抽象。
   对象：具体存在的实体。

5.成员变量和局部变量的区别
  a. 成员变量：类中，作用范围在整个类中有效。
  b. 局部变量: 在方法中，作用范围仅在方法内部。

6. 匿名对象
   a. 对象的简化用法：直接 new Car();
   b. 一般用于对象只用一次的情况。

class ClassDemo 
{

    //属性
    int num;//成员变量
    
    //行为
    public static void main(String[] args) 
    {
        System.out.println("Hello World!");
    }
}

 

5.3 封装
1. 封装：隐藏对象的属性和实现细节，对外提供公共访问方式
   优点：隔了变化、便于使用、提高重用、安全可靠。
   原则：只有一个门（内部内容隐藏）、把钥匙看好（把成员变量隐藏，提供公共方法对其访问）；

2. 访问修饰符：private 私有；类内部使用。
                    public 公有：整个程序使用。
                    protect 保护；相关类中使用。

3. 定义set/get方法对成员变量进行访问

4. 私有仅仅是封装的表现形式之一，类、函数都是封装，隐藏细节，暴露入口；
    私有只能修饰成员变量。

class Person
{
    private int age; //age私有化--钥匙；通常将类中成员变量都私有化，对外提供方法访问，让其具有可控性。

    public void setAge(int age) //将局部变量赋值给成员变量；看好了钥匙
    {
        if(age<0)//加入健壮性、安全性判断；对成员变量进行控制
        {
            this.age=age;
        }
        
    }
    public int getAge()//看好了钥匙
    {
        return age;
    }

    void speak() //门
    {
        System.out.println("age="+age);
    }
}
class ClassDemo 
{

    public static void main(String[] args) 
    {
        Person p = new Person();
        //p.age= 20;
        //p.speak();

        p.setAge(20);
        System.out.println("age="+p.getAge());
        p.speak();
    }
}

 

5.4 构造函数
1. 特点：函数名与类名相同；不用定义返回值；没有具体返回值。
   作用：给对象初始化
   注意：默认构造函数的特点；多个构造函数是以重载的形式存在的。

2. 构造函数和一般函数有什么不同
   a.构造函数用于给对象初始化时只执行一次，一般函数可以调用多次。

class Person
{
    private String name;
    private int age;
    //定义一个构造函数；如果不定义，系统默认一个空的构造函数。对对象进行初始化！
    //如果自己定义了构造函数，默认的构造函数就没有了！
    public Person()
    {
        System.out.println("我是构造函数!");
    }
    //构造函数重载，一个类中有多个构造函数。
    public Person(String n, int a)
    {
       if(a<0)
         return;
       name=n;
       age=a;
    }
    
}

class ClassDemo 
{

    public static void main(String[] args) 
    {
        //每一个对象被创建的时候都要被初始化
        Person p = new Person(); //当对象创建的时候，就要调用构造函数。
        Person p2= new Person("王三"，12); //创建对象时，初始化对象
    }
}

 

5.5 this关键字
1. this 关键字代表其所在函数所属对象的引用，即本类对象的引用
2. 什么时候使用this关键字呢？
   （1）当函数内需要用到调用该函数的对象时，就用this.
   （2）当成员变量和局部变量同名时，可以用this来区分。
   （3）使用this(参数)的方式就可以实现构造函数之间的调用。
    注意：构造函数之间调用时，this语句只能放在构造函数的第一行。
3. 当功能内部使用到本类对象时，用this表示

class Person
{
    private String name;
    private int age;
    perosn(String name)
    {
        this.name = name;
    }
    perosn(String name,int age)
    {
        this.name = name;//1.this使用1：this 代表当前对象,实际为对象的引用，谁调用就this就是谁
        this("小米");// 2. this使用2：构造函数调用，this
        this.age = age;
    }

    void speak()
    {
        System.out.println("name:"+name+"age"+age);
    }

    public boolean compare(Person n)
    {
        if(this.age = n.age)//3. 当功能内部使用到本类对象时，用this表示
            return true;
        else
            return false;
    }
}
class ThisClass
{
    public static void main(String[] args)
    {
        Person p = new Person("王五"，24);
        p.speak();
    }
}

 

5.6 static 关键字
1. static用于修饰成员函数和成员变量
2. 被修饰后的成员具备以下特点：
   （1）随着类的加载而加载
   （2）优先于对象的存在而存在--生命周期过长！
   （3）被所有对象所共享
   （4）可以被类名直接调用
3. 使用注意
   （1）静态方法只能访问静态成员
   （2）静态方法中不可以写this/super关键字
   （3）主函数是静态的

4. 成员变量和静态变量的区别：
   （1）生命周期：
        成员变量随着对象的出现而出现，随对象的消失而消失。
        静态变量随着类的出现而出现，随类的消失而消失。
  （2）内存的存储地址：
        成员变量存在堆内存的对象中
        静态变量存储在方法区的静态区中
   （3） 存储数据的特点
         成员变量存储的数据是对象的特有数据
         静态变量存储的数据是对象的共享数据
   （4）调用方式
         成员变量：只能被对象调用
         静态变量，能被对象和类名同时调用。
5. 静态的使用
   （1）当成员变量的数据所有对象都是一样的，该数据可以用Static修饰。
   （2）函数是否有访问类中的静态成员变量.

6. 静态代码块，随着类的加载而执行，而且只执行一次，用于给类初始化。
   static
   {

   }
7. 构造代码块和局部代码块
   {//构造代码块，创建对象时，给所有对象初始化。而构造函数给对应的对象初始化。

   }

   {//局部代码块，控制局部变量的生命周期

   }

 

class Person
{
    String name="Wang";
    static String country="CN";
}

class StaticDemo
{
    public static void main(String[] args)
    {
        System.out.println(Person.country);//类名直接调用
    }
}

 

5.7 单例设计模式
1. 单例设计模式：保证一个类在内存中的对象唯一性。
2. 如何保证对象的唯一性？
   a. 不让其他程序创建该类对象，因为数量不可控。————>构造函数为private，不让其初始化。
   b. 自己创建一个本类对象。
   c. 让其他程序对该对象有公共的访问。
3. 单例设计模式的两种方式

//饿汉式--建议用
class Single
{
    Single s = new Single(); //创建一个对象
    //构造函数私有化
    private Single()
    {

    }
    public Single getInstance(int age)//创建公方法获取该类对象
    {
        if(age > 20)
        {
            return s;
        }
        return null;
    }
}
//l懒汉式，延迟加载过程
class  Single2
{
    private static Singles2 s = null;
    private Single2(){};
    public static Single2 getInstanc()
    {
        if(s==null)
        {
            s =new Single2();
        }
        return s;
    }
}

说明:本博客是作者学习传智播客毕向东老师的JAVA基础课程所摘抄和记录的笔记，在此感谢传智播客，感谢毕向东老师。如有侵犯知识产权行为，请及时联系作者（swl880716@gmail.com）删除！