黑马程序员 面向对象（一）
1.面向对象的理解：
（1）面向对象是相对面向过程而言
（2）面向对象和面向过程都是一种思想
（3）面向过程强调的是功能行为
（4）面向对象是将功能封装进对象，强调具备了功能的对象。
（5）面向对象是基于面向过程的
（6）面向对象的三个特征：封装（encapsulation）继承（inheritance） 多态（polymorphism）
举例：将大象放进冰箱
2.类
（1）类就是同一类事物的统称，如果将现实生活中的一个事物抽象成对象，那么类就是这类对象的统称。
（2）类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。
（3）定义类其实就是在描述事物，就是在定义事物的属性和行为，属性和行为共同成为类的成员（成员变量和成员方法）
（4）主函数保证类的独立运行。
举例：
class Person //建立类
{ //类的属性
int age=20;
String name="李四";
//类的行为
void study()
{
System.out.println("study");
}
void sport()
{
System.out.println("sport");
}
}
class PersonDemo
{
public static void main(String[] args)
{
//在堆内存创建对象，p是一个类类型变量。记住，类类型变量指向对象
Person p=new Person();
//需求：将人的姓名改为张三，具有学习行为。指挥该对象的方式：对象.对象成员
p.name="张三";
System.out.println("name");
p.study();
}
}内存分配：
3.成员变量和局部变量
（1）作用范围：(a)成员变量作用于整个类中； (b)局部变量作用于函数或者语句中
（2）在内存的位置：(a)成员变量在堆内存中； (b)局部变量在栈内存中
（3）是否有默认初始化值：（a）成员变量有默认初始化值0；(b)局部变量没有默认初始化值
4.匿名对象
(1)创建匿名对象：new Car();
(2)匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化；如果对一个对象的成员方法进行多次调用，或者对成员变量进行调用，必须给这个对象起个名字。（注意，匿名对象不能调用成员变量，因为一调用成员变量就已经成为垃圾）
(3)匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。
//匿名对象示例
class Car
{ //轮胎数
int num=4;
//颜色
String color="红色";
//定义行为
void run()
{
System.out.println("running");
}
}
class CarDemo
{
public static void main(String[] args)
{
//创建匿名对象
show(new Car());
}
public static void show(Car c)
{
c.run();
}
}5.封装（Encapsulation)
（1）概念：封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
（2）好处：（a)将变化隔离；(b)便于使用；
(c)提高复用性；(d)提高安全性；
(3)函数是java中最小的封装体
(4)封装原则
(a)将不需要对外提供的内容都隐藏起来。
(b)把属性都隐藏，提供公共访问方式对其访问。
6.私有（private）
（1）私有是一个权限修饰符，用于修饰类中的成员（成员变量，成员函数），私有只在本类中有效。
（2）将成员私有化以后，类以外即使建立了对象也不能直接访问。需要在类中提供对应的访问方式，一个成员变量通常都对应两个访问方式：setXxx();getXxx();
（3）注意：封装不是私有的，私有仅仅是封装的一种表现形式。
（4）之所以对外提供访问方式，是为了提高代码的健壮性。
//封装示例
class PersonAge
{ //将age私有化
private int age;
//提供age的访问方式
public void setAge(int a)
{
if(a>0 && a<130)
{
age=a;
//函数调用
speak();
}
else
{
System.out.println("error age");
}
}
public int getAge()
{
return age;
}
void speak()
{
System.out.println("age="+age);
}
}
class PersonAgeDemo
{
public static void main(String[] args)
{ //建立对象
PersonAge a=new PersonAge();
//引用PersonAge类中的方法
a.setAge(20);
}
}7.构造函数
（1）特点：（a）函数名与类名相同
（b）不用定义返回值类型
（c）不可以写return语句
（2）作用：给对象进行初始化。
（3）注意：（a）多个构造函数是以重载的形式存在的。
（b）对象一建立就会调用与之对应的构造函数。
（4）构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，黑认的构造函数就没有了。
（5）构造函数和一般函数的区别：
（a）写法上有不同；
（b）在运行上有不同：构造函数是在对象一建立就运行，给对象初始化，而一般方法是对象调用才执行，是给对象添加对象具备的功能。
（c）一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。
（6）什么时候定义构造函数：当分析事物时，该事物存在就具备一些特性或者行为，那么将这些内容定义在构造函数中。
8.构造代码块
（1）作用：给对象进行初始化，对象一建立就运行，而且优先于构造函数执行。
（2）构造代码块和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。
//构造代码块和构造函数示例
class Person2
{
private int age;
private String name;
//构造代码块
{
System.out.println("cry.....................");
}
//利用重载方式建立多个构造函数
Person2()
{
System.out.println("A:age="+age+";name="+name);
}
Person2(int a)
{ age=a;
System.out.println("B:age="+age+";name="+name);
}
Person2(int a,String n)
{ age=a;
name=n;
System.out.println("C:age="+age+";name="+name);
}
}
class PersonDemo2
{
public static void main(String[] args)
{
Person2 p1=new Person2();
Person2 p2=new Person2(20);
Person2 p3=new Person2(30,"李四");
}
}9.this关键字
（1）this:用于区分局部变量和成员变量同名情况
（2）this代表它所在函数所属对象的引用。简单说，哪个对象在调用this所在函数，this就代表哪个对象
（3）this可以用于构造函数之间的互相调用，而且构造函数间的调用只能用this。（4）this(name）；只能定义在构造函数的第一行，因为初始化要先执行。
//this关键字示例
class Person2
{
private int age;
private String name;
//建立构造函数
Person2()
{
System.out.println("A:age="+age+";name="+name);
}
Person2(int age)
{ this.age=age;
System.out.println("B:age="+age+";name="+name);
}
Person2(int age,String name)
{ this(age); //用this调用对应的构造函数
this.name=name;
System.out.println("C:age="+age+";name="+name);
}
}
class PersonDemo3
{
public static void main(String[] args)
{
Person2 p1=new Person2();
Person2 p2=new Person2(20);
Person2 p3=new Person2(30,"李四");
}
}
10.static（静态）关键字
（1）作用：static用于修饰成员（成员变量和成员函数）。
（2）特点：
(a)随着类的加载而加载；
(b)优先于对象存在；
(c)被所有对象所共享；
(d)可以直接被类名调用；
（3）使用注意：
(a)静态方法只能访问静态成员
(b)静态方法中不可以写this，super关键字
(c)主函数是静态的
（4）实例变量（成员变量）和类变量（静态成员变量）的区别：
(a)存放位置：
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
(b)生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
（5）静态的利处与弊端
利：(a)对对象的共享数据进行单独空间的存储，节省空间，没有必要 每一个对象中都存储一份；
(b)可以直接被类名调用，Person.show()；
弊：(a)生命周期过长；
(b)访问出现局限性。（静态只能访问静态）存在于堆内存中。
（6）什么时候定义静态变量？
当对象中出现共享数据时，该数据被静态所修饰，对象中的特有数据要定义成非静态。
（7）什么时候定义静态函数？
当功能内部没有访问到非静态数据（对象的特有数据）时，那么该功能可以定义成静态的。
11.主函数：public static void main(String args[])
（1）主函数是一个特殊的函数，作为程序的入口，可以被jvm调用。
（2）主函数的定义：
public：代表着该函数访问权限是最大的
static:体表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
(String[] args)：主函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数据。
（3）主函数是固定格式的，jvm识别；jvm在调用主函数时，传入的是new String[0];
//静态函数示例
class Person4
{
String name;
/*show()函数内部没有访问到非静态数据
（对象的特有数据）时，那么该函数可
以定义成静态的。*/
static void show()
{
System.out.println("haha");
}
}
class PersonDemo4
{
public static void main(String[] args)
{ //show()函数可以直接被类名调用
Person4.show();
}
}
12.帮助文档的制作
（1）帮助文档（java说明书）是通过文档注释来完成的。制作帮助文档可以让使用者了解类中的方法。
13.静态代码块
（1）格式：
Static
{静态代码块中的执行语句}
（2）特点：随着类的加载而执行，只执行一次
14.对象的初始化过程
Person p=new Person(“zhangsan”,20);
这句话都做了什么事？
（1）因为new用到了Person.class，所以会先打到Person.class文件并加载到内存中
（2）执行该类中的static代码块，如果有的话，给Person.class类进行初始化
（3）在堆内存中开辟空间，分配内存地址。
（4）在堆内存中建立对象的特有属性，并进行默认初始化。
（5）对属性进行显示初始化
（6）对对象进行构造代码块初始化
（7）对对象进行对应的构造函数初始化
（8）将内存地址赋给栈内存中的p变量
15.单例设计模式
（1）模式一（饿汉式）：解决一个类在内存只存在一个对象。
（2）保证对象唯一的方法：
(a)为了避免其他程序过多建立该对象，先禁止其他程序建立该对象
(b)还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象
(c)为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式
//饿汉式
class Student
{
private int age;
public void setAge(int age)
{
this.age=age;
}
public int getAge()
{
return age;
}
private Student(){}
private static Student s=new Student();
public static Student getInstance()
{
return s;
}
}
class StudentDemo1
{
public static void main(String[] args)
{
Student s1=Student.getInstance();
Student s2=Student.getInstance();
s1.setAge(10);
System.out.println("s1:"+s1.getAge());
s2.setAge(15);
System.out.println("s2:"+s2.getAge());
}
}（3）模式二（懒汉式）：对象是方法被调用时，才初始化，也叫做对象延时加载。
//懒汉式
class Student
{
private int age;
public void setAge(int age)
{
this.age=age;
}
public int getAge()
{
return age;
}
private static Student s=null;
private Student(){}
public static Student getInstance()
{
if(s==null)
s=new Student();
return s;
}
}
class StudentDemo
{
public static void main(String[] args)
{
Student s1=Student.getInstance();
Student s2=Student.getInstance();
s1.setAge(10);
System.out.println("s1:"+s1.getAge());
s2.setAge(15);
System.out.println("s2:"+s2.getAge());
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
