黑马程序员 面向对象(一)
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());
}
}