黑马程序员_面向对象

------- android培训、java培训、期待与您交流！ ----------

 

1.面向对象

类

class

-> 自定义一个类. 

如何定义类. 

class 类名{

成员变量(属性)

成员方法(行为)

}

类是模板,有了类可以根据类创建对象. 

对象

堆内存中的一块实体空间. 

存储了对象的属性. 

new

-> 创建对象. 

通过new 关键字创建对象. 在堆内存开辟了空间.存储了对象的属性. 

类类型 对象名=new 类名();

虽然是通过new 操作符创建的对象, new 操作符返回一个结果,该结果是对象的引用(地址值),非对象本身. 

对象的使用

-> 如何使用对象.

可以通过对象名. 的形式操作对象. 

1. 对象名.属性名=值; 

给对象的属性赋值. 

2. 对象名.属性名

取出对象的属性

3. 对象名.成员方法

执行对象的特有的行为. 

匿名对象

-> 存在的意义.

简化书写的方式.

1. 调用方法 

如果调用成员方法时, 只需要使用一次,可以使用匿名对象. 

new 类名().成员方法();  虽然使用new 操作符创建了一个对象,并执行了该对象的方法,但是只要方法执行完毕该对象

立即变为了垃圾(来及回收是不定时回收的). 

2. 作为方法的实际参数传递的. 

public Car repairCar(Car car){

 

}

Car c=new Car();

repairCar(c);

***************

封装

解决的问题,程序出现了问题. 需要使用该种方式解决? 

 

-> 封装的实现的方式. 

成员变量私有,公有的get set 方法 这就是封装的一种实现方式... 

-> 存在的意义. 

如果使用封装, 在其他类中,可以直接通过对象名.属性名的方式直接访问对象的属性. 可以属性赋值. 

出现非法的数据,对象保存了非法的数据,程序不够安全和健壮了... 

如何有效的过滤非法数据. 

1. 类的成员变量私有

其他类中, 无法通过对象名.属性名的方式直接访问该对象的属性类. 

2. 该类提供公有的get 和set 方法. 

可以在方法中加入逻辑判断,过滤非法的数据.

(只不过偷懒了... )

注意: private 实现方式仅仅是封装的一种体现... 

     方法(函数) 也是封装的一种体现... 

     一段独立功能的程序. 可以解决特定的问题,实现特定的目标... 

     Arrays.sort(数组);

dry  电脑...

主板, cpu ,内存,硬盘,电源... -> 跑了... 

风险高-> 避免安全隐患. 将电脑封装到主机箱中... 

不能封死,对外提供操作... 开机按钮,网卡口... 

对外提供开机按钮,usb ,网卡开口... 

-> 封装的好处:

隐藏了类的具体的实现(侧重隐私的).

成员变量私有的话,对外(其他类)隐藏改成员变量...

如果不提供get 和set 方法的话,在其他类中确实无法访问了... 

提高了对象的数据(属性)的安全性

在set方法中,过滤了非法数据.

提高了程序的可维护性安全性. 

提高了可维护性?

成员变量私有->无法直接通过对象. 属性的形式访问对象的属性了.

但是可以通过get 和set 方法访问... 

可以根据实际需求决定是否要提供get 或者set . 

如果需要对外提供属性->添加get 方法. 

如果需要对象提供修改属性->添加set 方法... 

员工:

工号

get 

no set

工资:

no get

set  

构造函数

作用

初始化对象. 

使用

通过创建对象时, new 操作符后 添加具体的实际参数,jvm 根据实际参数匹配对应的构造函数... 

构造函数在创建对象时,有jvm 根据实际的参数调用的,用于初始化对象的属性的. 

一个类中可以存在多个构造函数,是以重载的形式存在. 

重载: 函数名相同, 参数列表不同的. 

构造函数的特点:

1. 函数名和类名相同

2.没有返回值

3. 没有返回值类型, 和void 不同. 

4. 自定义类,如果没有提供构造函数,编译器提供一个无参数构造(默认),如果自定义了构造函数,默认的无参数构造就没有了

构造代码块

在一个类中直接以一对花括号存在{} 

作用: 初始化对象

构造函数的不同:

只要创建对象就会执行,并且优先于构造函数执行. 在创建对象的整个周期内只执行一次. 

构造函数,jvm 根据具体的实际参数确定对应的构造函数.  

this

含义:

对象的引用. 

使用场景

可以用在成员方法中

可以用在构造函数中. 

作用

1.用在成员方法中,可以区分成员变量和局部变量同名的问题.

set 方法. 

this.成员变量=局部变量. 局部变量的值赋值给了成员变量(属性)

注意:成员方法的依赖于对象. 需要通过对象名.成员方法的形式调用... 

哪个对象调用该方法,方法内部的this 就是那个对象了.

2. 用在构造函数的第一行. 调用本类的其他构造函数. 

this() -> 调用无参数构造. 

this("jack",28); 调用有参数构造.参数一为String,参数二位int 

注意的如果在一个构造函数中,调用本类的另一个构造函数,这个语句需要在第一行.

因为java 希望初始化的动作优先执行... 

static

静态

修饰成员变量

使用场景,作用是什么

类变量, 不需要创建对象,可以直接通过类名来访问了.

静态变量随着类的加载初始化,存在于方法区(类的字节码文件.class 文件也存储在方法区)由于类只加载一次,静态变量只有1份. 

如果对象和对象之间出现了共享的数据,可以使用静态变量. 

实际开发:

public static final  数据类型 常量名=常量值; 

静态和常量和公共一起出现. 

公共的->访问权限最大.都可以直接通过类名访问. 

static -> 静态的,只有1个. 

final  ->最终的,不能被改变的,常量 

public static final dobule PI=3.14

Math.PI . 

修饰成员方法

使用场景,作用是什么. 

如果设计的方法,不想创建对象,就像调用的话,直接将方法设计为静态的... 

什么时候考虑使用这样的方法呢?

设计工具类时, 例如Arrays Collections  Maths 这些工具类...  

为了方便的让大家使用导工具类中的方法,直接将所有方法设置为静态的,有了避免多余的创建对象,将工具类的构造函数私有化. 

只能通过 类名.方法名访问了工具类中的方法了...

静态代码块

随着类的加载而执行,并只执行一次. 

想要执行第二次或者第三次,重新启动程序...  所以在整个正序的运行周期内,只执行一次. 

适合初始化类(程序)

例如: 静态代码块中连接库... 

     图书管理系统初始化书库...

*****************

类和类之间的关系

继承

extends 

解决了什么问题,好处的什么. 

如果类和类之间符合is a 的关系... 

ia a   

xxx 是 yyy 的一种(一类)

可以使用继承建立类和类之间的关系. 

如果建立了继承关系,可以提高代码的复用性,减少重复代码... 

1.描述类和类之间的关系,并减少了重复代码,提高代码的复用性. 

注意:

不要为了减少重复代码就使用继承,要符合is a 关系. 

super

使用场景

子类中. 

1. 访问父类属性. 

2. 访问父类的成员方法. 

3. 访问父类的构造函数. 

在子类的构造函数第一行有默认的语句super() ,创建子类对象时,先默认的调用父类的无参数构造. 

当子类的构造函数中,自定义的调用类父类的构造函数时,默认的super() 就没有了... 

注意: 如果在构造函数中,调用父类的构造函数是,不同同时出现this,调用本类的构造函数. 

都是初始化的动作,都需要在第一行. 

class fu{

private String name; 

fu(){

 

}

fu(String name){

this.name=name;

}

public void setName(String name){

this.name=name;

}

public String getName(){

return name; 

}

}

class zi extends fu{

zi(){

 

}

zi(String name){

super(name);

}

}

class sun  extends zi{

sun(){

 

}

sun(String name){

super(name);

}

}

重写

override 覆盖. 

存在的意义,java设计了重写的意义.

使用前提:

子父类中(实现类实现接口的实现类中),子类继承类父类的方法,如果父类的方法无法满足子类的需求,子类可以重写父类的方法. 增强子类的方法.

核心:

子类是比父类强的. 

使用场景:

子类继承类父类,父类是抽象类,存在抽象方法. 

子类如果调用该方法,必须重写... 

实现类实现类接口,接口中有方法. 

实现类实现类该接口,如果想要调用该方法,必须重写... 

注意:

子类继承父类, 实现类实现接口中. 

函数名要形同,参数类表一致,修饰符(子类>=父类),返回值类型(子类方法返回值类型<=父类方法的返回值类型)

Object 在java 是一个顶层的父类 比较大的. 

Object 子类 就是小的. 

class Animal{}

class Dog extends Animal{}

 

class Father{

Animal getAnimal(){

return new Animal(); 

}

}

class Son extends Father{

public Dog getAnimal(){

return new Dog(); 

}

}

Dog < Animal 

重写只存在于非静态成员方法,和成员变量,静态方法没有关系的... 

final 

使用场景

1.修饰成员变量

普通的变量,可以取值和赋值. 如果不想修改变量的值. 可以将变量设置为常量.final修饰. 

2.修饰成员方法

普通的成员方法(非私有的),子类继承并重写该方法, 如果父类不希望子类重写,可以将方法设置final. 

3.修饰类

如果该类不希望有子类... 

4.修饰形参.

避免形参随意的修改...

抽象类

abstract 

抽象方法:

如果一个类中的成员方法,方法体不明确,无法确定,可以将方法设计为抽象方法,交给子类来实现(重写)

修饰符 abstract 返回值类型 函数名(参数列表);-> 没有方法体的方法,并使用abstract 声明了的就是抽象方法了...  

抽象类:

如果一个类中存在一个以上的抽象方法,该类必须声明为抽象类... 

修饰符 abstract class 类名{

 

}

 

使用场景

实际开发中,将符合is a 关系的类, 组成一个体系, 有所谓的顶层父类和底层的实现类. 

将顶层的父类设计为抽象类,顶层的父类的方法的方法体是不确定(明确)抽象的... 

注意事项

抽象类不能创建对象. 

抽象类中存在抽象方法,功能是不完整,如果能够创建抽象类对象的,调用到抽象方法后,是没有任何意义. 

抽象类可以有成员变量可以有构造函数,可以有非抽象方法 

都是给子类使用的. 体现了继承的思想,提高代码的复用性... 

抽象类当然可以没有抽象方法

目的仅仅是为了禁止创建对象.->如果是抽象类,即使使用反射技术,也无法创建出该类对象...

使用事项:

子类继承抽象类. 

1. 子类要么重写父类中的所有的抽象方法,

子类继承的父类,如果父类还继承的有父类, 子类就需要重写全部的继承下的抽象方法... 

2. 子类要么也声明为抽象类. 

不需要重写抽象方法了,抽象类允许存在抽象方法.      

接口

interface  implements  

语法:

interface 接口名{

public static final 属性; 

public abstract 返回值类型 函数名(); 

}

使用事项:

1.类实现接口要么重写该接口中的所有方法... 

2.类实现接口要么声明为抽象类.

3. 一个类可以同时实现多个接口. 

3. 接口和接口之间是继承关系,一个接口可以继承多个接口.  

思考题：

设计一个类．　

表示古代的皇帝，　

皇帝比较特殊，唯一的．．．　

如果描述了皇帝类，该类在整个程序中只能创建一个对象．　只能有１个．．．

创建对象：

如何保证对象的唯一性　　

单例设计模式. 

设计模式:

解决一类特定的问题时,发明了特定的代码适合解决该问题... 

单例:

1. 构造函数私有. 

禁止在其他类中创建该类对象. 

2. 本类提供一个本类对象. 

在成员变量的位置设置一个本类对象的成员变量,并初始化(创建本类对象).

3. 提供静态方法获取到这个本类对象. 

 

 　    

*/

public class Demo1{

public static void main(String[] args){

for(int i=0;i<10;i++){

System.out.println(Emperor.getEmperor());

}

}

}

// 单例(单态)-> 保证该类对象的唯一性...   

class Emperor{

// 本类类型的成员变量. 

private static final Emperor em=new Emperor(); 

 

// 构造函数私有

private Emperor(){

 

}

// 公共静态方法获取到本类对象. 

public  static Emperor getEmperor(){

return em; 

}

}