黑马程序员 Java基础<一>---> 面向对象与类之概述(匿名对象、封装、构造函数、this、静态等)

时间:2023-02-16 17:10:00

----------- android培训java培训、java学习型技术博客、期待与您交流! ------------


第一节   概述

一、面向对象的概述:

         java是一种面向对象的编程语言,也就是说对象是这种语言的基础,没有对象了,就没有了java。任何功能都是通过对象来实现的,就是将功能封装进对象,让对象去调用这些功能。这种思想是将数据作为第一位,而方法(功能或者说是算法)作为其次。我个人认为,这是对数据的一种优化,安全性更高,操作起数据来一更方便。

         那么将这种思想提升到一种境界就是:万物皆对象。

1、对面向对象的理解:

1)面向对象是相对面向过程而言的,且基于面向过程的。

2)面向对象是一种思想。

3)面向对象将功能封装进对象中,强调了具备功能的对象,主体是对象,将过程简化

4)在实际开发中,以对象为核心,先明确好对象,在实现具体功能,或者可是使用已有的对象。

5)面向对象的三个特征:封装性,继承性,多态性。

2、举例说明:

人是一个对象,人有吃饭,睡觉以及学习等等的行为(可称为功能),那么就是将吃饭、睡觉以及学习等功能封装进人这个的事物中,让人去执行这些功能,是人在调用这些方法,从而简化了过程。


第二节   类与对象


一、类与对象概述

1、类(class):可以理解为是构造对象的一个蓝图或者模板,是抽象的概念;反过来说,对象是以类为模型创造的具体实例,是对类的一种具体化、形象化。

类:对生活中事物的描述

对象:对类的具体实现,是实实在在存在的实体。

2、例如:汽车的设计

类:指的是汽车的设计图纸

对象:指实际生产出来的汽车。


示例:

/**
需求|:定义一个汽车类,要求设计出汽车的型号(即名字),颜色,轮胎个数,行驶速度,并且让汽车行驶起来(即打印出每个汽车的颜色、轮胎数、速度)
并比较两辆汽车之间那个性能更好|:即速度快慢
思路|:
1创建一个构造函数,即一个汽车类,对其的颜色,轮胎数。行书速度,速度,以及其方法,即行驶等进行初始化
2在main方法中创建一个汽车对象,并实现其功能
3构造一个方法,比较两辆车之间的速度大小
*/class Car
{
String name;
String color;
int nums;
double speed;
Car(String name,String color,int nums,double speed)
{
this.name = name;
this.color = color;
nums = 4;
this.speed = speed;
System.out.println(name + "是一辆" + color + ",轮胎数是:" + nums + ",可以行驶的速度是:" + speed);
}

public void compare(Car c)
{
if(this.speed > c.speed)
{
System.out.println(this.name + "行驶得更快。");
return;
}
System.out.println(c.name + "行驶得更快。");
return;
}
}

class CarDemo
{
public static void main(String[] args)
{
Car a = new Car("奔驰","黑色的",4,500);
Car b = new Car("宝马","蓝色的",4,600);
a.compare(b);
}
}

二、成员变量与局部变量:

在类中的不同位置定义变量,作用范围是不同的,下面简单区分一下,两种变量的不同:

1)作用范围:

   a.成员变量:作用于整个类中

   b.局部变量:作用于函数中,或者作用于语句块中。

2)在内存中的位置:

   a.成员变量:在堆内存中,因为对象的存在才在内存中存在。

   b.局部变量:在栈内存中,随着函数的结束而消亡

3)初始化方式:

   a.成员变量:随着类的初始化而初始化,在堆内存中被加载,有默认值,可直接参与运算

   b.局部变量:随着方法的加载而加载进栈内存中,无初始化值,必须被初始化才能参与运算


上面汽车的例子中,a、bc是局部变量,定义在了方法中,存在于栈内存中;而name、color、nums和speed都是成员变量,存在于堆内存中,随着类的加载而加载。


三、匿名对象

1、简述:所谓匿名对象,就是创建的对象没有名字,直接使用。

2、使用方式:

1)使用方式一:当对对象的方法只调用一次时,可以使用匿名对象来完成,这样写比较简化。

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

2)使用方式二:可以讲匿名对象作为实际参数进行传递,从而可以不用在main方法中创建一个变量,提高了编程效率,减少了代码书写。

      但是这个对象实体在方法结束后,垃圾回收机制会将其作为垃圾回收。而非匿名对象则不同,当不使用了,会在某一时刻被回收,或是随着主函数的结束而被回收。


第二节  封装

一、概述

1、定义:封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。

2、好处:

a.将变化隔离

b.便于使用

c.提高重用性

d.提高安全性

3、原则:

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

b.把属性都隐藏,提供公共方法对其访问

4、说明:

a.私有仅仅是封装的一种表现形式,如包也是一种封装形式

b.之所以对外提供访问方式,就是因为可以在访问方式中加入逻辑判断等语句,对访问的数据进行操作,提高了代码的健壮性。


二、private 关键字

1、private是一个权限修饰符

2、用于修饰成员(成员变量和成员函数)

3、被私有化的成员只在本类中有效。

4、常用之一:将成员变量私有化,对外提供对应的set和get 方法对其进行访问,提高了对数据访问的安全性。

5、当把类中的所有构造函数私有化后,代表着该类是不能创建对象的,因为对象不能进行初始化操作的。


示例:

/**需求:定义一个private变量,并定义两个方法,一个返回其值,另一个提供新值位于60-100之间的数给变量
思路:定义一个类,其属性包括一个变量,以及包括两个方法
一个方法返回变量的值,另一个方法提供60-100之间的值给变量
*/

class Virus
{
private int newSeconds = 0;
public int getSeconds()
{
return newSeconds;
}

public void setSeconds(int x)
{
if(x>60 || x<100)
{
newSeconds = x;
}
}
}

class VirusText
{
public static void main(String [] args)
{
Virus a = new Virus();
a.setSeconds(78);
System.out.println(a.getSeconds());
}
}

三、成员访问权限比较

                                                                         权限大小

成员修饰符     public       protected       default(默认)       private

同一个类中       OK               OK                    OK                     OK

同一个包中       OK               OK                    OK                     NO

子类访问           OK               OK                    NO                     NO

不同包中           OK               NO                    NO                     NO

四、public类与源文件名

一个编译单元(个人理解为执行main函数所调用到的所有文件)中只能有一个public类,且这个类的文件名必须要和其类名相同,包括大小写也必须一样。

原因:

1、一个编译单元只能有一个public类的原因:

第一、public的意思是所有类都能访问,包括包以外的类。public是作为这个编译单元的公开接口存在的。

第二、java程序的入口是main方法,所以被定为public的这个类一定是main方法的类,且这个类的名称要和文件名一直,因为虚拟机是要开始找main方法这个入口的。

第三、你可以根据需要,添加任意辅助功能的public权限的类,但是如果这个编译单元(注意是编译单元)里面有两个或以上public类的话,那么编译器就会报错。

建议:

第一、不要在一个源文件中写多个类。在标准的java代码编写时,无论代码量是多少,最好一个源文件只有一个类或接口(即使是接口也要如此),因为java是面向对象的语言,每个类都是抽象的结果,所以每个类要单独写在一个源文件里。

第二、只要要有一个是public类,虽然可以在编译单元中没有public类,即没有公开的接口,可在同一个包中访问,但是这样就将这个包都封闭了,是没意义的。如果没public,就可以随意给文件起名,可以不和类名相同。

2、被public修饰的类与文件名必须同名的原因:

第一、java是被编译执行的,它在运行时并不是将你写的所有类都先加载一遍的,而是当遇到import或使用到了其他类的时候,才会去在文件目录中找相应的class文件的。

第二、对于一个public类。上面也说了,是可以被项目中的任何一个类引用的,只需通过import导入即可。既然是作为虚拟机入口的main函数要用public修饰而成为一个公共接口,那么将类名和文件名一一对应就可以方便虚拟机在相应的路径(包名)中找到相关的信息;但是你如果不这么做,虚拟机很难去找,开销也会跟着增大的。

 

简单总结:

public作为一个公共接口(此接口非interface这个接口),修饰作为虚拟机入口的main函数,就是为了方便虚拟机找到相应的类,从而节省开销。


第三节   对象与函数

一、main函数:

我们刚开始接触java的时候就是用到了main函数,那么主函数是什么呢?在此分别对主函数的各个关键字及修饰符进行简单说明:

public static void main(String [] args){....}

1、主函数:是一个特殊的函数,作为程序的入口,可以被JVM识别并调用,它的格式是固定的。

2、主函数的定义:

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

2)static  :代表着主函数随着类的加载就已经存在了,一边执行函数中的代码。

3)void    :主函数没有具体的返回值,只是作为执行程序的入口。

4)main  :不是关键字,和其他的函数名类似,只不过别定义为一个特殊的单词,可以被JVM识别。

(String [] args)):函数的参数,参数类型是一个String类数组,元素为字符串。字符串类类型是数组,args是一个变量名,是约定俗成的,早期被写成arguments;如果改写成其他名称也是可以的。

3、注意:

可以重载主函数,但是虚拟机只识别固定格式的主函数,即 public static void main(String [] args){....}。


二、构造函数

先看一个简单的小程序

//创建一个简单的雇员类
public class Employee
{
//构造Employee函数
public Employee(String name,int age,double salary)
{
//将变量定义为private
private this.name = name;
private this.age = age;
private this.salary = salary;
}

{
System.out.println("我来工作了");
}

//访问器方法,获取name
public String getName()
{
return name;
}
//获取age
public int getAge()
{
//限制age的值
if (age<18)
{
System.out.println("不好意思啦,我们不接收未成年人!嘿嘿");
return;
}
return age;
}
//获取salary
public double getSalary()
{
return salary;
}
//修改雇员工资:涨byPercent个百分点的工资
public void setSalary(double salary,double byPercent)
{
salary + = salary*byPercent/100;
}
}


其中的public Employee(String name,int age,double salary)就是对这个类Employee的构造函数

1、特点:

a.函数名与类名相同

b.不用定义返回类型,括号中的参数可以没有,也可以有多个。

c.不可以写return语句

d.构造函数总是伴随着new操作一起被调用。

e.细节:当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数,即:类名(){}。但当类中自定义了构造函数后,默认的构造函数就不存在了。也就是说,每一个类中一定含有一个构造函数。

2、作用:给对象进行初始化

3、注意:

a.默认构造函数的特点

b.多个构造函数时以重载形式存在的。

3、构造函数与一般函数的区别:运行上不同

构造函数时在对象一建立就运行,是给对象初始化的。且一个对象建立后,构造函数只运行一次。

一般函数时对象调用才执行,是给对象添加对象具备的功能的。一般函数可以被该对象多次调用。

注:

     一般函数是不能调用构造函数的,因为一般函数中不能定义this,而构造函数中可能存在this。

4、何时定义构造函数:

当分析事物时,该事物存在具备一些特性或行为,那么将这些内容定义在构造函数中。也就是说,一类事物一出现就应该存在的特性,这就需要构造函数对其进行初始化。

5、构造代码块:

如上面的小程序,其中打印的“我来工作了”这个语句块就是构造代码块。它和构造函数作用类似,只不过仅用一对花括号括起来即可。

1)作用:给对象进行初始化,对象一建立就运行,且优于构造函数执行,即在构造函数前加载。

2)与构造函数区别:

构造代码块是给所有对象进行统一初始化,是所有对象的共性初始化方式内容。如任何孩子出生都要哭几声。

构造函数是给对应的对象初始化,不同的对象有各自的特性,需要选择不同的构造函数初始化。


     <<<<<------------------------------------------------------------------------------------------------------------------->>>>>

      补充:

      this关键字:

      1、this:表面上,是用于区*部变量和成员变量同名的情况。即this代表着当前对象的引用。

      2、this的用法:

      a.用于区分同名变量的情况。当局部已经定义了变量,当需要找成员中的变量,且变量名相同时,为了区*部变量和成员变量的相同变量名,可以使用this加以区分。

      b.用于构造函数间的调用。

      3、特点:

      1)this代表了本类的对象,即代表了它所在函数所属对象的引用,也就是说,哪个对象调用这个函数,this就代表哪个对象。

      2)一般情况下,this都是被省略的,需要使用的时候才需加上。

       如上面构造函数中的this的使用。

      4、this应用:

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

            只要本类功能内部使用了本类对象,都用this表示。

      5、在构造函数中的应用:

           this语句:用于构造函数之间的互相引用。且只能放在构造函数的第一行,否则编译失败。

       原因:初始化的动作要先执行,因为自身的特性要先具备;如果初始化中还有初始化,要限制性更细节的操作,然后再执行自己所需求的初始化。

      注意:不允许两个构造函数间相互调用this语句,否则会出现死循环。

               一般函数中不能定义this语句。

     <<<<<------------------------------------------------------------------------------------------------------------------->>>>>


三、static之静态函数

我们在学习java的最初就接触到了static这个修饰main方法的修饰符,那么static在java中有什么特点和作用呢?下面是对static的总结的几点:

一)总体来说static有这么几个特点:

  1、随着类的加载而加载,在类中生命周期最长

  2、优先于对象而存在

  3、可以被所有对象共享

  4、可以直接被类名调用

二)static的用法:

  1、修饰成员:包括成员变量和成员方法

当成员被static修饰后,就多了一种调用方式,即可以被对象和类名调用

需要注意的一点:static绝对不能修饰局部变量。为什么呢?

局部变量的作用域就是它所在的方法或代码块中,而static的变量刚是定义在类中方法体外,是作为整个类共同使用的,它从类加载开始就存在,而局部变量在它所在的方法或代码块结束后就要被回收的。所以是不能修饰局部变量的

1)静态常量:

例如:在Math类中定义了一个静态常量PI

public class Math  
{  
    ...  
    public static final double PI = 3.14159265358979323846;//final将PI设置为不可再定义的常量
    ...  
}

如果省略了static,PI就变成了一个实例常量,那么,每一个Math对象就都有自己的一个PI拷贝了,这样的话,对内存也是一种占用。

2)静态变量

如果将变量定义为static,那么每个类中只有这样一个变量。例如:

class Student
{
private int id;
private static int nextId = 1;
//获取id的访问器
public int getId()
{
return id;
}
public void setId()
{
id = nextId;
nextId++;
}
}

每个学生都有自己的一个id号,但这个Student的所有对象都共享一个nextId,即使不存在对象,也仍存在nextId,因为它是属于类的,而不属于任何独立的对象,所以它是随着类的加载而加载的,随着类的消亡而消亡的。

3)静态方法:

静态方法是一种不向对象进行操作的方法。当方法被static修饰的时候,此方法是用类名.方法名的方式使用的,当然也可以用对象名.方法名,但是这样就会产生误解,会让别人以为这个方法是非静态的,这样就有些不合理了。但是静态方法有一点需要注意的是:静态方法只能访问静态成员,因此静态方法也就不能定义this和super等关键字了。

那么在什么时候用到静态方法呢?

第一、当一个方法不需要访问对象是,其中所需的参数都是通过显示参数提供的。比如说Math.sqrt(double n)

第二、一个方法只需要访问累的静态变量时,如Person.getCountry();

private static String country = "CN";//因为国家是共有的,共享
public static void getCountry()
{
return country;
}

3、静态的应用:

当每个应用程序都有共同之处,可将其封装,提高其复用性。

需要注意的是:

a.对象时用于封装数据的;

b.对数据的操作方法,若没用到方法中特有的数据,则无需创建对象而占用多余的内存。

4、静态代码块

特点:a.随着类的加载而执行,且优先于主函数;b.只执行一次,类再创建对象,则不再执行,已经存在于内存中。

格式:

static
{语句}

5、静态是用注意事项:

1)静态方法只能访问静态成员,非静态方法既能访问静态也可以访问非静态

2)静态方法中不可定义this,super等关键字,因为静态优先于对象存在,所以静态方法中不可以出现this

3)主函数是静态的。

6、静态有利有弊:

好处:对对象的共享数据惊醒单独空间的存储,节省空进。没必要每个对象中都要存储一份,可以直接被类名调用

弊端:生命周期过长。访问出现局限性,因为静态只能访问静态。

举例:

class Student
{
private static String country = "CN";//因为国家是共有的,共享
private int id;
private static int nextId = 1;
//静态代码块
static
{
System.out.println("Hello");
}
public static String getCountry()
{
return country;
}
public int getId()
{
return id;
}
public void setId()
{
id = nextId;
nextId++;//前一个人获取id后,然后一个人获取下一个id时就加1
}
}

class StudentText
{
public static void main(String [] args)
{
Student st1 = new Student();
st1.setId();
System.out.println("st1'country = " + Student.getCountry() + "; st1id = " + st1.getId());
Student st2 = new Student();
st2.setId();
System.out.println("st2'country = " + Student.getCountry() + "; st2id = " + st2.getId());
}
}


运行结果如下:

黑马程序员 Java基础<一>---> 面向对象与类之概述(匿名对象、封装、构造函数、this、静态等)

第四节   单例设计模式


在java中存在很多通用的设计模式,今天我简单总结一下单例设计模式: 解决问题:解决一个类在内存中只存在一个对象的问题(比如说一个软件中的配置文件) 一、如何保证对象的唯一性: 1、为避免建立过多的该类对象,应首先禁止其他应用程序创建该类对象。 2、为让其他应用程序访问到该对象,在本类中自定义一个对象,为避免直接访问该对象,要对其进行私有化。 3、提供访问方式,便于其他程序对自定义对象的访问,提供的访问方法是公有的。 对象保证是惟一的了,那么该如何具体实现呢? 二、使对象唯一性的步骤: 1、将构造函数私有化 2、在类中创建一个本类对象,并设置为私有的 3、提供一个公有的方法获取该对象,便于使用 三、单例设计模式的具体表现形式 具体代码如下: 1、饿汉式:先初始化对象,类一进内存就加载
//饿汉式
class Single
{
private Single(){}
private static Single s = new Single();
public static Single getSingle()
{
return s;
}
}

class SingleText
{
public static void main(String [] args)
{
Single s1 = Single.getSingle();
Single s2 = Single.getSingle();
if (s1==s2)
System.out.println(true);
else
System.out.println(false);
}
}

2、懒汉式:类进内存,对象还没有存在,只有调用了getSingle方法时,才建立对象
//懒汉式
class Single
{
private Single(){}
private static Single s = null;
public static Single getSingle()
{
if (s==null)
s = new Single();
return s;
}
}

class SingleText
{
public static void main(String [] args)
{
Single s1 = Single.getSingle();
Single s2 = Single.getSingle();
if (s1==s2)
System.out.println(true);
else
System.out.println(false);
}
}

运行的结果是:true;这是因为s1和s2引用的是同一个对象,所以符合条件。

但是对于第二种懒汉式的单例设计模式,会出现一些小小的问题,当一个线程调用时,是没什么问题的,如果多个线程调用此种方式,那么就会出现问题。
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if (s == null)
{
synchronized(Single.class)
{
if (s == null)
s = new Single();
}
}
return s;
}
}

比如说,当A调用时,当读到if(s1==null) 时,可能就停在这了,然后cpu再调用B,B也读到if(s1==null)这停下了,cpu再切换到A,接着创建一个对象,A就执行完了;之后B也向下执行,又创建一个对象;此时,对象就不唯一了,就破坏了对象的唯一性的初衷。那么解决方案是这样的:
这利用了锁的机制。synchronized是java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。这涉及到了多线程的问题。在这个例子中,比如说,A调用时,当读到第二个if(s1==null) 时,可能就停在这了,然后cpu再调用B,B读到第一个if(s1==null)这停下了,因为加上synchronized后,A进去就相当于将其他的调用锁在外面的语句上了,要先执行完A,那么A执行完后,就已经创建了一个对象;当B再读到第二个if(s1==null)的时候不符合就直接结束了。如果再有其他C或D等调用的时候,就直接不符合第一个(s1==null)的条件,所以直接返回s。在这里,我们再来看看关于懒汉式的多线程问题:

上面的懒汉式的写法,是效率比较高的,先看看下面一段代码,比较一下,就会清晰很多:
class Single
{
private static Single s = null;
private Single(){}
public static synchronized Single getInstance()
{
if (s == null)
s = new Single();
return s;
}
}

在这两种方式中,含有双重判断(称为第一种,无双重判断的为第二种)的效率更高,为什呢?虽然第一种和第二种都要先判断一下,但是对于第一种,第一个线程执行完后,s不为null了,那么后面只需要判断s是否为null即可,而对于第二种,要先判断锁,锁里没有线程,再进入,然后再判断一下s是否为null,这样一来,就要判断两次,所以,效率会更低。所以,对于双重判断,是可以提高效率的。

问题是解决了,但是相比之下,还是第一种饿汉式的单例设计模式更好一些,是一种建议使用的方式。