黑马程序员--Java基础之面向对象(上)

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！


Java面向对象整理（内容实在是不少，小妞分上下两部分吐血整理）

一、参数传递

JAVA中的参数传递问题：
1.基本类型（值传递）：形式参数的改变对实际参数没有影响；
2.引用类型（址传递）：形式参数的改变直接影响实际参数。
注：在java中二者统称为值传递，即将引用类型传递的定义为地址值，也是一种值。
实际上，基本类型可以用局部变量的知识解释，调用函数的形参仅在这个函数内部有效，出了这个被调用的函数，将被主函数中的同名参数覆盖掉。

二、面向对象与面向过程

面向过程就是分析解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候一个一个依次调用就可以了。
面向对象则是把解决的问题按照一定的规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。

面向过程：面向过程是以函数为基础，完成各种操作，强调的是功能行为
面向对象：面向过程是以对象为基础，完成各种操作，将功能封装进对象，强调具备了功能的对象
面向对象是基于面向过程的

面向对象思想的特点：
A：是一种更符合人们思考习惯的方法
B:可以将复杂的事情简单化
C:将程序员从执行者转换成了指挥者

面试时可举的例子：
招人的例子：一个可以自己做，选择找一个人来替我做

举例：洗衣机洗衣服：传统的手洗衣服是面向过程的，人需要经历泡衣服，搓洗衣服，拧干水等过程；而有了洗衣机之后，洗衣服的过程就成了面向洗衣机这个对象的过程，人只需要调用洗衣机泡衣服，洗衣服，甩干等功能即可完成洗衣服全过程。

面向对象：怎么着让我们的操作更符合面向对象思想呢？
A：分析该系统中包含哪些对象？
B:明确每个对象可以做什么？
C:明确各个对象之间的关系


面向对象的三大特性：
1.封装性：将对象的属性和行为封装起来，不需要让外界知道
2.继承性：类与类之间的关系
3.多态性：同一个属性和方法在不同的类中具有不同的语意

三、类与对象

以后开发其实就是找对象使用，没有对象就创建一个对象

找对象，建立对象，使用对象，维护对象的关系

类和对象有啥子关系：
（面试）类与对象的关系：(掌握)
把事物转换成类：
A:成员变量
定义在类中，方法外。
B:成员方法
和以前的区别是去掉static。

类：是相关的属性和行为的集合。是一个抽象的概念。
对象：是某种事物的具体存在，具体的表现形式。

举例：
类：学生
对象：张三
现实生活中的对象：张三 李四
想要描述：提取对象中共性内容，对具体的抽象
描述时：这些对象的共性有：姓名，年龄，性别，学习java功能

类就是属性和行为的集合，是一个抽象概念
对象就是类的具体存在的个体

坑来啦~~
下列说法哪个正确？  C
A．不需要定义类，就能创建对象   ×
B．对象中必须有属性和方法   ？？
C．属性可以是简单变量，也可以是一个对象   
D、属性必须是简单变量

关于类和对象的叙述正确的是：(   )
A．Java的类分为两大部分：系统定义的类和用户自定义的类   
B．类的静态属性和全局变量(成员变量)的概念完全一样，只是表达形式不同 ？
C．类的成员至少有一个属性和一个方法 ？错了吧
D．类是对象的实例化 ×反了

下列说法哪个正确？　　（　ABC　）
A. 一个程序可以包含多个源文件   //导包？？？？？？？？？？
B. 一个源文件中只能有一个公共类  ×
C. 一个源文件中可以有多个类
D. 一个源文件只能供一个程序使用  ×？

(一)成员变量和局部变量

成员变量和局部变量的区别：

1.位置的区别：
成员变量：定义在类中，方法外的变量
局部变量：定义在方法中的变量
如：
class Person
{
int age = 10;//成员变量
void speak()
{
int age = 60;//局部变量
System.out.println("大家好，我今年"+age+"岁");//打印的是局部变量的值
}
}

2.在内存中的存储位置的区别：成员变量在堆内存中，因为对象的存在，才在内存中存在
 局部变量：存在栈内存中

3.成员变量和局部变量初始值的不同：
成员变量都有默认值，不赋值也可以参与运算，是在堆内存中 成员变量自动赋初值


局部变量不初始化不能参与运算，因为是在栈内存中        局部变量必须手动赋值  千万表忘记啦
4.作用范围：成员变量作用于整个类中
局部变量作用于函数中或者语句中

此处有坑，请小心！

Java会自动为成员变量进行初始化

Person p = new Person();
p.say();
p = null;
p.say();//会报错，空指针异常（NullPointerException）

Test：
给定java代码，如下，编译运行，结果是（A）
public static void main(String[] args){
boolean flag;//局部变量必须初始化！！！！！！！！！！！！！
System.out.println(“flag”+flag);
}
A. 编译错误
B.  编译通过，单出现运行时错误
C.  正常运行，输出flag=false
D.  正常运行，输出flag=

下面关于变量及其范围的陈述哪些是对的? (  ACD )
A. 实例变量(区别于类变量，属于对象的变量)是类的成员变量。
B. 实例变量用关键字static声明。 ×
C. 在方法中定义的局部变量在该方法被执行时创建
D. 局部变量在使用前必须被初始化。

(二)匿名对象

匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
如果对一个对象进行多个成员调用，必须给这个对象起个名字
匿名对象使用方式二：可以将匿名对象作为实际参数进行传递
eg：new Student().show()

四、类的封装

封装：
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：将变化隔离
     便于使用
     提高重用性
     提高安全性
封装原则：将不需要对外提供的内容都隐藏起来
把属性都隐藏，提供公共方法对其访问


访问权限：
1.private：私有；修饰类中的成员变量及成员函数；私有只在本类中有效。
 将成员变量私有化之后，类以外即使建立了对象也不能直接访问，当需要访问成员变量时，就需要在类中提供对应访问私有成员变量的方法。（将年龄私有化以后，类以外即使建立了对象也不能直接访问
但是人应该有年龄，就需要在Person类中提供对应访问age的方式。）
 私有仅仅是封装的一种表现形式。

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

类的成员变量都加private，提高安全性

涉及到对象都要写set、get方法


2.一个java文件中只能有一个public类  记住了啊。。差点被坑了

注意 注意：1.变量的使用范围
     2.就近原则

五、this关键字

this：看上去，是用于区分局部变量和成员变量同名情况。
this为什么可以解决这个问题？this到底代表的是什么呢？

this：就代表本类对象，到底代表哪一个呢？
     this代表它所在函数所属对象的引用。简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

this用于解决局部变量隐藏成员变量的问题，解决成员变量和局部变量名称冲突的问题

如果局部范围内没有name，就不加this
例：
class Worker
{
private int age = 20;


public void show()
{
int age = 18;
System.out.println(this.age); //问题是这里的打印age是多少? 20
}
}

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

this语句：用于构造函数之间进行互相调用。只能定义在构造函数的第一行。因为初始化要先执行。
class Person
｛
private String name;
private int age;

Person(String name)
{
this.name = name;
}
Person(String name,int age)
{
this(name);
this.age = age;
}

｝

A:概念：用于在方法中访问对象的其他成员；
B：用法
a.调用成员变量，解决与局部变量名称冲突问题；
b.调用成员方法，
eg.
this.show(name,age)；
c.调用构造方法,
eg.
this(参数)；
注意点：1.这种调用形式只能在构造方法中调用其他构造方法时使用，不能在成员方法中使用；
2.此语句必须位于构造方法的第一行，且只能出现一次；
3.不能在一个类的两个构造方法中使用this相互调用，这样会形成类似死锁。

六、代码块

（一）构造函数

构造函数的特点：(1.方法名和类名相同 2.无返回值类型 3.无明确返回值)
1.构造函数没有返回值！只有修饰符，不能使用return语句返回一个值。


注意：2.一旦手动建立构造函数，原先默认的无参构造函数将消失，所以一定要手动给出无参构造函数。牢记！！！！！

给成员变量赋值：1.用set函数，这种方法可动态改变变量值。（推荐）
 2.用构造函数（一次性赋值，不可再改变）。


3.构造函数一般是用public来修饰的，这样方便建立对象；但是构造函数也可以用private修饰，但是此时需
 满足如下条件：
main函数中建立对象时所调用的构造函数不是被private修饰的构造函数。

eg.class Demo
{
int a;
int b;
private Demo(){};

}
class  Test
{
public static void main(String[] args) 
{
//（1）Demo d = new Demo();


}
}
编译不会报错，但是如果将（1）加入到代码中则会报错。

（二）构造代码块

构造代码块：定义在方法外的代码块
构造代码块中定义的是不同对象共性的初始化内容
｛
cry();
｝

（这个知识点主要是面试用）
作用：给对象进行初始化(或者说是把所有构造函数中共同的内容提取出来)
     对象一建立就运行，而且优先于构造函数执行。new一个执行一次
特点：用于定义不同对象共性的初始化内容。
与构造函数的区别：
构造代码块是给所有对象进行统一初始化；而构造函数是给对应的对象初始化。
class Person
{
private String name;
private int age;
{
System.out.println("person code run");//这就是构造代码块！
}
Person()
{
System.out.println("A:name="+name+",age="+age);//构造函数
}
}

（三）静态代码块

static
{
静态代码块中的执行语句
}

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

（四）哎~重点来了

代码块(面试题)
(1)执行顺序：
静态代码块 --> 构造代码块 --> 构造方法
eg.继承中的执行顺序：
父类静态代码块-->子类静态代码块-->父类构造代码块-->父类构造方法-->子类构造代码块-->子类构造方法
(2)注意事项：
静态代码块只执行一次。

七、垃圾回收

垃圾回收：
1.等待JVM进行自动垃圾回收
2.调用System.gc()方法通知JVM立即进行回收。当一个对象在内存中被释放时，它的finalize()方法会被自动调用。必须是public void 
public void finalize()
{
System.out.println("对象被当作垃圾回收。。。");
}

八、内存相关

1.无限循环中，尽量不要出现创建对象，这样会导致不断的创建对象，处理不好容易导致内存溢出！

2.对象的初始化过程在内存中的体现。

3.一个类中各块的加载顺序以及在内存中存储的位置。

4.初始化过程：
Person p = new Person("zhangsan",20);

该句话都做了什么事情？
1.因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中
2.执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4.在堆内存中建立对象的特有属性，并进行默认初始化
5.对属性进行显式初始化
6.对对象进行构造代码块初始化
7.对对象进行对应的构造函数初始化
8.将内存地址赋给栈内存中的p变量

九、static关键字

1.用法：是一个修饰符，只能用于修饰成员（成员变量，成员函数）。不能修饰局部变量
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用：类名.静态成员

2. static特点：
1）.随着类的加载而加载。也就是说，静态会随着类的消失而消失，说明它的生命周期最长。
2）.优先于对象存在。明确一点：静态是先存在的，对象是后存在的
3）.被所有对象所共享
为什么要使用静态呢？如果某个内容是被所对象所共享，那么，该内容就应该用静态修饰。
没有被静态修饰的内容，其实是属于对象的特殊描述。
4）.可以直接被类名所调用  记住

3.实例变量和类变量的区别：
1）.存放位置。
 类变量随着类的加载而存在于方法区中
 实例变量随着对象的建立而存在于堆内存中
2）.生命周期。
 类变量生命周期最长，随着类的加载而加载，消失而消失
 实例变量生命周期随着对象的建立而建立，消失而消失

4.静态使用注意事项：
1）.静态方法只能访问静态成员  举例说明：StaticTest.java
   非静态方法既可以访问静态也可以访问非静态。
2）.静态方法中不可以定义this，super关键字
 因为静态优先于对象存在，所以静态方法中不可以出现this
3）.主函数是静态的
4）.静态内容可以通过对象调用，也可以通过类名调用（推荐通过类名调用）

5.静态有利有弊：
利：对对象的共享数据进行单独空间的存储，节省空间。没必要每一个对象中都存储一份。可以被类名调用。
弊：生命周期过长
  访问出现局限性（静态虽好，只能访问静态）

6.什么时候使用？
a.定义静态变量：对象中出现共享数据时。
b.定义静态函数：当功能内部没有访问到非静态数据时（如没有用staitc修饰的成员变量，成员方法）。

下面对static的描述正确的是  ACD
A. 静态修饰的成员变量和成员方法随着类的加载而加载
B. 静态修饰的成员方法可以访问非静态成员变量   × 
C. 静态修饰的成员可以被整个类对象所共享
D. 静态修饰的成员变量和成员方法随着类的消失而消失  ×  睁眼吧

十、Math类和Random类的随机数

Math类的随机数(掌握)
类名.调用静态方法。

包：java.lang
类：Math
方法：public static double random():

java.lang包下的类是不用导包就可以直接使用的。

调用Math类的random()方法可以获取0~1之间的随机数 [0,1)

产生1-100之间的随机数：
int number = (int)(Math.random()*100)+1;

Random类的随机数
包：java.util
类：Random
构造方法：
Random（）：种子为当前时间的毫秒值，产生的随机数每次都不同
Random（long seed）：给定种子，只要种子不变，产生的随机数是一样的

导包：import java.util.Random;
Random r = new Random();
int number = r.nextInt(100)+1;//产生1-100之间的随机数

十一、单例设计模式

设计模式：解决某一类问题最行之有效的办法。
java中23种设计模式：
单例设计模式:解决一个类在内存只存在一个对象。
在设计一个类时，需要保证在整个程序运行期间针对该类只存在一个实例对象

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

这三步用代码怎么体现呢？
1.将构造函数私有化
2.在类中创建一个本类对象
3.提供一个方法可以获取到该对象。

对于事物该怎么描述还怎么描述，当需要该事物的对象保证在内存中唯一时，就将以上三步加上即可
例：
class Student
{
private int age;


private static Student s = new Student();
private Student(){}
public static Student getStudent()
{
return s;
}


public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
}




单例设计模式两种方式：饿汉式、懒汉式


饿汉式：先初始化对象
例：Single类一进内存，就已经建立好了对象
class Single
{
private static Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
（面试！！！）懒汉式：对象被方法调用时，才初始化，也叫做对象的延时加载
例：Single类进内存，对象还没有存在，只调用了getInstance方法时，才建立对象
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
s = new Single();
return s;
}
}

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;
}
}

定义单例，建议用饿汉式

1.方式一：
class Single
{
private static Single INSTANCE=new Single();
private Single(){}
public static Single getInstance()
{
return INSTANCE;
}
}
特点：
A.类的构造方法是用private修饰，声明为私有，这样就不能在类的外部使用new关键字来创建实例对象了；
B.在类的内部创建一个该类的实例对象，并使用静态变量INSTANCE引用该对象，由于变量应该禁止外界直接访问，因此使用private修饰；
C.为了让类的外部创建一个该类的实例对象，需要定义一个静态方法getInstance(用于返回该类实例INSTANCE。由于方法是静态的，外界可以通过类名来访问。


2.方式二：
class Single
{
private Single(){}
public static final Single INSTANCE=new Single();
}
特点：A.将类的构造方法私有，防止外界创建该类的实例；
B.在类的内部创建该类的实例对象，并使用静态变量INSTANCE来引用，变量INSTACNE的前面有三个修饰符：
public：作用是允许外部直接访问该变量；
static：作用是让外部可以使用类名来访问变量；
final：作用是禁止外部对该变量进行修改
C.由于访问变量INSTANCE是获得Single类实例对象的唯一方式，因此该类实现了单例。