黑马程序员--Java基础之面向对象一

 

知识提纲：

1，理解面向对象思想

2，类与对象

3，封装的理解

4，构造函数

5，this，static

6，主函数

7，单例设计模式（饿汉式，懒汉式）

8，继承

 

1，面向对象

面向对象就是相对面向过程而言的。如把大象装进冰箱，c语言强调的是功能行为：打开冰箱——>把大象装进冰箱——>关闭冰箱。而Java面向对象的思想就是强调具有功能的对象：冰箱打开，冰箱存储，冰箱关闭。感觉上就是过程是你自己亲自在做，而面向对象却是你指挥着对象去做。面向对象和面向过程都是一种思想，面向对象是基于面向过程的。

1.1，面向对象的特点：

        1. 是一种符合人们思考习惯的思想

        2. 可以将复杂的事情简单化

        3.将程序员从执行者转换成了指挥者

        4. 完成需求时：

                a)先要去找具有所需的功能的对象来用。

                b) 如果该对象不存在，那么创建一个具有所需功能的对象。

                c) 这样简化开发并提高复用。

        在Java的开发过程，其实就是不断的创建对象，使用对象，指挥对象做事情。设计的过程，其实就是在管理和维护对象之间的关系。

面向对象的三个特征：

        封装（encapsulation）  继承（inheritance）  多态（polymorphism）

面向对象的最高境界：万物皆对象（面试时慎用）。

2，类与对象

2.1，类与对象的关系

如图我们可以理解为：类就是图纸。汽车就是对象。

类的定义：

       使用计算机语言就是不断的描述现实生活中的事物，而java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。

       生活当中描述事物无非就是描述事物的属性和行为。如：人的身高，体重等属性；讲话跑步等行为。Java则是用类class来描述对象的属性和行为。定义类其实就是在定义类中的成员（成员变量和成员函数）。

       属性：对应类中的成员变量。

       行为：对应类中的成员函数。   

而对象即是该类事物实实在在存在的个体。

<span style="font-size:18px;"><span style="font-size:18px;">class Person{    int age;private void speak(){System.out.println("age="+age);}}</span></span>

2.2，成员变量和局部变量

       之前我们用到的基本都是局部变量，现在我们将会使用成员变量。其实它两都是变量，规范写法上也没啥区别，都是标识符，但是在作用范围和内存中分配不同。

区别：

       成员变量：

                a)成员变量定义在类中，在整个类中都可以被访问。

                b) 成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

                c) 成员变量有默认初始化值。

       局部变量：

                a) 局部变量只定义在局部范围内，如：函数内，语句内等。

                b) 局部变量存在于栈内存中。

                c) 作用的范围结束，变量空间会自动释放。

                d) 局部变量没有默认初始化值。

2.3，匿名对象

       匿名对象是对象的简化形式。

       匿名对象两种使用情况

                1、当对对象方法仅进行一次调用的时。

                2、匿名对象可以作为实际参数进行传递。

例： new Car();

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

3，对象的封装

3.1、 概念

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

3.2、 好处

        a）将变化隔离。

        b）便于使用。

        c）提高重用性。

        d）调高安全性。

3.3、 原则

        a)  将不需要对外提供的内容都隐藏起来。

        b)  把属性都隐藏，提供公共方法对其访问。

3.4、 封装的表现形式之一——private（私有）

        private关键字：权限修饰符；用于修饰类中的成员（成员变量，成员函数）；私有只在本类中有效。

       常用之一：

               将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。

        如：我有一个人对象，而年龄这一属性我不想被对象访问，我就可以将其设为private。

人物对象程序：

class personDemo
{
 public static void main(String[] args)
 {
  //System.out.println("Hello World!");
  person p=new person();
  p.setAge(40);
  p.speak();
 }
}

class person
{
 private int age;
 public void setAge(int a)
 {
  if(a>0 && a<130)
  age=a;
  else
   System.out.println("非法输入");
 }

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

}

4，构造函数

4.1、 特点：

        a） 函数名与类名相同。

        b） 不用定义返回值类型。

        c） 不可以写return语句。

4.2、 作用：

        给对象进行初始化。

4.3、构造函数的小细节：

       当一个类中没有定义构造函数时，系统就会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。

4.4、构造函数和一般函数在写法上有不同，在运行上也有不同：

        构造函数式在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能。一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。

4.5、什么时候定义构造函数？

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

4.6、构造代码块

       作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数运行。

和构造函数的区别：

       构造代码块是给所以对象进行初始化。

       而构造函数是给对应的对象初始化。

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

class person
{
 private int age;
 private String name;
 person()
 {
  System.out.println("name="+name+"  , age="+age);
 }

}

5，this关键字 5.1，this代表它所在函数所属对象的引用。

       简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

5.2，this的应用：

       当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。

       但凡本类功能内部使用到了本类对象，都用this表示。

5.3，this语句：

       用于构造函数之间进行互相调用。如：this(name);

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

5.4，对this的概括总结：

        this的两种用法：1、用于区分同名变量的情况，说的成员和局部同名的时候；2、用于构造函数间调用。

注：一般函数不能直接调用构造函数，因为this语句不能用在一般函数中，只能用在构造函数间。

class person
{
 private int age;
 private String name;
 person()
 {
  System.out.println("name="+name+"  , age="+age);
 }
 
 person(String name)
 {
  this.name=name; //this 用于区分局部变量和成员变量同名情况
 }
 person(String name,int age)
 {
  this.name=n;
  this.age=a;
 }

 public boolean Compare(person p)
 {
  return this.age==p.age; //此时一定要用this来表示p1这个对象
 }

6，static（静态）关键字      static是一个修饰符，用于修饰成员（成员变量和成员函数）。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。格式：类名.静态成员。

6.1，static特点：

        1、随着类的加载而加载。

            也就是说：静态会随着类的消失而消失，说明它的生命周期最长。

        2、优先于对象存在。明确一点：静态是先存在。对象是后存在。

        3、被所有对象所共享。

        4、可以直接被类名所调用。

       由于静态成员可以直接被类名调用，因此静态成员变量又称为类变量。而非静态成员变量又被称为实例变量。

6.2，实例变量和类变量的区别：

        1、存放位置。

            类变量随着类的加载而存在于方法区中。

            实例变量随着对象的建立而存在于堆内存中。

        2、生命周期。

            类变量生命周期最长，随着类的消失而消失。

           实例变量生命周期随着对象的消失而消失。

6.3，静态有利有弊：

       利处：对对象共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。

       弊端：生命周期过长。

                 访问出现局限性。（静态虽好，只能访问静态）。

6.4，什么时候使用静态？

       从两方面下手： 因为静态修饰的内容有成员变量和函数。

       1、什么时候定义静态变量（类变量）呢？

       当对象中出现共享数据时，该数据被静态所修饰。

       对象中的特有数据要定义成非静态存在于堆内存中。

       2、什么时候定义静态函数呢？

       当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

6.5，静态使用注意事项：

        1、静态方法只能访问静态成员。

            非静态方法既可以访问静态也可以访问非静态。

        2、静态方法中不可以定义this，super关键字。

            因为静态优先于对象存在。所以静态方法中不可以出现this。

        3、主函数是静态的。

静态代码块：

       格式：

              static

              {

                          静态代码块中的语句。

              }

特点：随着类的加载而执行，执行一次。并优先于主函数。用于给类进行初始化。,

6.6，对象的初始化过程：

       定义一个新对象都做了哪些事情？

        1、把类名.class文件加载到内存中。

        2、执行该类中的static代码块，如果有得话，给该类进行初始化。

        3、在堆内存中开辟空间，分配内存地址。给对象

        4、在堆内存中建立对象的特有属性。并进行默认初始化。

        5、对属性进行显示初始化。

        6、对对象进行构造代码块初始化。

        7、对对象进行对应构造函数初始化。

        8、将内存地址赋给栈内存中的对象名变量。

 

7，主函数：

主函数是一个特殊的函数。作为程序的入口，可以被JVM调用。

主函数的定义：

        public：代表着该函数访问权限是最大的。

        static：代表主函数随着类的加载就已经存在了。

        void：主函数没有具体的返回值。

        main：不是关键字，但是是一个特殊的单词，可以被JVM识别。

      （String[] arr）：函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

        args：arguments 参数 。唯一可以更改的地方。

主函数是固定格式的：被JVM识别。

8，单例设计模式

设计模式的概念：解决某一问题最行之有效的方法。java中共有23种设计模式。

接下来我们讲解其中的一种：单例设计模式。

单例设计模式的作用：使一个类在内存中只存在一个对象。

用代码实现单例设计模式需要做三步：

        1、将构造函数初始化。

            例：private Single(){}

        2、在类中创建一个本类对象。

             例：private static Single s= newSingle（）；

        3、提供一个访问方法可以获取到该对象。

             例：public static Single getInstance（）

                     {

                            returns;

                      }

单例设计模式只是为了保证内存中的对象唯一，其他在类中该怎么描述吗，还是怎么描述。

单例设计模式有两种写法：

        8.1、饿汉式：也就是刚三部中的示例语句。它的特点是先初始化对象。如：Single类一进内存，就已经创建好了对象。在实际开发中，出于安全考虑，建议使用饿汉式。

 

/*
设计模式：JOF 一共23种，解决某一类问题最行之有效的方法

单例模式：解决一个类在内存中之存在一个对象

想要保证对象唯一
1.为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象
2、为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象
3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式

怎么体现
1、将构造函数私有化
2、在类中创建一个本类对象
3、提供一个方法可以获取到该对象

对于事物该怎么描述，还怎么描述
当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可

*/

class single
{
 private single(){}

 private static single s=new single();

 public static single getInstance()
 {

  return s;
 }

}

class SingleDemo
{
 public static void main(String[] args)
 {
  singel ss= single.getInstance();

 }
}

 8.2、懒汉式：它的特点对象是方法被调用时，才初始化，这也叫对象的延时加载。如：在以下完整代码中，Single类进内存，对象还没有存在，只有调用了getInstance()方法时，才创建对象。

//对象时方法被调用时，才初始化，也叫做对象的延时加载，称为 懒汉式
//single类进内存，对象还没有存在，只有调用geiInstance方法时，才建立对象

class single
{
 private static single s=null;
 private singel(){}
 public static single getInstace()
 {
  if(s==null)
   s=new single();
  return s;
 }

}

9、继承

 9.1、概念： 继承是面向对象的一个重要特征。当多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继那个类即可。这时，多个类可以称为子类，单独的这个类称为父类或者超类。例如：猫和豹子都是猫科动物，那么就可以说描述猫这个对象创建的类，是子类；而描述猫科动物这个对象创建的类，就是父类。

        这样类与类之间就存在了继承的关系。子类可以直接访问父类中的非私有的属性和行为。在代码中通过extends关键字表示继承关系。例：

            class Sonextends Father{}  //这也是在代码中的书写格式。

注意：千万不要为了获取其他类中的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。这种所属关系的表示为is a。

9.2、特点

        1、提高了代码的复用性。

        2、让类与类之间产生了关系。有了这个关系，提供了多态的前提。

注：Java语言中，只支持单继承，不支持多继承。例：一个儿子只能有一个父亲。

      原因：因为类与类多继承的话，容易带来安全隐患。如：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪个一个。

        但是Java保留了这种机制，并用另一种体现形式来完成。叫多实现。

9.3、继承的应用

        Java类中虽然不支持多继承，但可以多层继承。也就是一个继承体系。如儿子继承父亲，父亲继承爷爷等。用代码体现就是：

           class A{}

           class B extendsA{}

           class C extendsB{}

     那么如何使用一个继承体系中的功能呢？

     想要使用体系，先查体系中父类的描述，因为父类中定义的是该体系中的共性功能。通过了解共性功能，就可以知道该体系的基本功能。这样这个体系就可以基本使用了。

     在具体调用时，要创建最子类的对象。原因：

     一是因为有可能父类不能创建对象。

     二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简单一句就是：查阅父类功能，创建子类对象使用功能。
9.4、子父类出现后，类成员的特点

类成员
a、变量
b、函数
c、构造函数

    变量   如果子类中出现非私有的同名成员变量时
子类要访问本类中的变量用this，要访问父类中的变量用super，

    函数     当子类出现和父类一模一样的函数时，调用子类对象的函数时，
会运行子类函数的内容，如同父类的函数被覆盖一样
这中情况是函数的另一个特性：重写（覆盖）

覆盖：  注意事项
a、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败
b、静态只能覆盖静态

c、子父类中的构造函数

class Father
{
 int num=4;
 void show()
 {
  System.out.println("fu show"); 
 }
 void speak()
 {
  System.out.println("vb"); 
 }

}

class Son extends Father
{
 int num=5;
 void show()
 {
  System.out.println("zi show"); 
 }
 void speak2()
 {
  System.out.println("java"); 
 }
}

class Tel
{
 void show()
 {
  System.out.println("number"); 
 }
}
class NewTel extends Tel
{
 void show()
 {
  //System.out.println("number"); 
  super.show(); //如果是爷爷辈的呢
  System.out.println("name"); 
  System.out.println("pic"); 
 }
}

class ExtendsDemo
{
 public static void main(String[] args)
 {
  Son s=new Son();
  s.show();
  //System.out.println(s.num+"::"+s.num);
 }
}
9.5、子父类中的构造函数
在对子类对象进行初始化时，父类的构造函数也会运行
那是因为子类的构造函数默认第一行有一条隐式的语句 super();

super(); 会访问父类中空参数的构造函数，
而且子类中所有的构造函数都会访问父类的空参数构造函数

为什么子类一定要访问父类的构造函数、

因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的
所以子类在对象初始化时，要先访问下父类中的构造函数
如果要访问父类中指定的构造函数，可以通过手动定义super（）来访问父类构造函数

注意：super()语句一定定义在子类构造函数第一行
子类的实例化过程
结论：子类中所有的构造函数，默认都会访问父类中空参数的构造函数
因为子类的每一个构造函数内的第一行独有已经隐式的super();

当父类中没有空参数的构造函数，子类必须手动通过super()语句形式来指定要访问父类中的构造函数

当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数
子类中至少会有一个构造函数会访问父类中的构造函数
class Father //extends Object
{
 int num;
 Father()
 {
  num=97;
  System.out.println("fu");
 }

 Father(int x)
 {
  System.out.println("fu....."+x);
 }

}

class Son extends Father
{
 Son()
 {
  //super();
  super(95);
  System.out.println("zi");
 }
 Son(int a)
 {
  //super();
  System.out.println("zi......."+a);
 }

}

class ExtendsDemo2
{
 public static void main(String[] args)
 {
  Son s=new Son(); //先走父，后走子
  Son s1=new Son(5);
 }
}

class Person
{
 private String name;

}

运行结果为：

10、final : 最终  作为一个修饰符
   10. 1.可以修饰类，函数，变量，
   10.2、被final 修饰的类不可以被继承，被子类复写功能
   继承打破了封装性
为了避免被继承，使用final，就不会被继承
    10.3、被final修饰的方法，不可以被复写
    10.4、被final修饰的变量时一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量
 当在描述事物时，一些数据的出现值是固定的，那么这是为了增强阅读星，读给这写值起个名字
作为常量，书写规范是所有字母大写，多个单词用下划线_连接
    10.5、内部类定义在类中的局部位子上时，只能访问该局部被final修饰的局部变量

class Demo
{
 final void show1()
 {

 }
 void show2()
 {
 }
}

class A extends Demo
{
 //void show1(){}
}

class FinalDemo
{
 public static void main(String[] args)
 {
  System.out.println("Hello World!");
 }
}