OOP大纲

OOP大纲

一、类与对象

1.1 面向对象

①OOP 即面向对象编程，java就是面向对象编程的语言。

②世界由万物组成，万物都是对象（万事万物皆为对象）

③面向对象思想：

第一步：发现类 Person

第二步：发现类的属性

第三步：发现类的方法

1.2 对象

①任何一个对象都可以用名词 + 动词来描述；

②对象 = 名词（属性、特征）+ 动词（行为、方法）；

③我们通过类来创建对象用new关键字；对象就是类产生出来的实例。

Dog d = new Dog(); 此处d称之为对象名

人  是对象吗？ 是

1.3 属性

属性：名词，用来描述对象的特征；

d.name=”旺财”;

1.4 类

类：即模板，是不同对象的共同属性和方法集合；

（我们将一些对象的共同属性和方法抽取出来，形成了类，类是对象的模板）

类是引用类型，OOP初级阶段我们一定要形成一种意识：

【精髓】学会把我们自己创建的类看作是一种数据类型！！！

Person p;

二、方法

方法：动词，用来描述对象的行为

方法的特性：①方法是用来描述一个对象的行为。②封装重复的代码，方便使用，避免代码冗余的现象。

简单写法： public void eat(){System.out.println(“吃”);}

Public static void main(String [] args){}

访问控制符 修饰符 返回值类型 方法名(参数列表){}

熟练掌握方法的创建：

①无返回值

public void ask(){}

②有返回值

public String toString(){//定义的返回数据类型和实际返回的数据类型必须一致

return “字符串”;

}

方法的调用：

Dog dog = new Dog();

Dog.myshow();

Dog.add(1,2);

Public void add(Student stu){}

Main(){

Student stu = new Student();

Stu.setName(“渣渣”);

Clazz c = new Clazz();

C.add(stu)

}

①不带参调用：对象名.方法();

②带参调用：对象名.方法(数据类型传参);

③对象传参：对象名.方法(对象传参);

例：d.ask(Student  stu);  // stu是对象名，类型是Student

对象传参是今后使用比较多的，请重点学习，做下学生信息的题目。

四种方法形式：

①无参无返回 public void a(){}

②无参有返回 public int b(){}

③有参无返回 public void c(int a){}

④有参有返回 public int d(int a){}

三、封装

3.1 什么是封装

封装：①私有化(private)属性，②公开读写方法(set/get)

封装：打包，就是不允许外部直接访问属性，而是通过该类提供的方法来实现对隐藏属性的操作和访问。

注意：对属性的操作只有两种：读（get）、写(set)

读(get)：即把属性的值读出来返回 

public 返回类型 getXxx(){return xxx}

写(set)：即把属性进行赋值

Public void setXxx(返回类型 xxx){this.xxx = xxx;}

3.2 为什么要使用封装？

有一种功能，在我们对这些属性赋值是对不符合常理的数据进行判断，确保数据的可读性。

①我们会把一些小类型的数据合在一个大类型的数据

②封装能够带来安全性

   通过公开方法（set/get）来对属性进行操作，并判定输入的数据是否是合法的

    (比如狗的年龄400，有这么大岁数的狗吗？)

3.3 封装与属性的区别

【区别】封装可以做判断

public int age; public void setAge(int age){ if(age>=0&&age<=150){ this.age = age; } } Private String sname; public String getSname(){ return sname; } public void setSname(String sname){ this.sname = sname; }

三、对象数组

将对象放入到数组中，看成是数组中的一个元素。

往数组中存放的是对象

熟练掌握对象数组的使用（增、删、改、查），多做下这方面的题。

对象数组的属性调用：数组[对象].属性;

对象数组的方法调用：数组[对象].方法;

Student[] stus = new Student[10];

Stus[2].getName()

四、方法重载overload

对方法进行重载，同一个类中存在多个方法名相同，参数不同的方法。

重载：同名不同参

  同名即方法名相同；

  不同参即参数个数、类型、顺序不同，与返回值无关。

构造方法也能重载，而且经常会使用到，建议了解。

五、构造方法

构造方法：与类同名，一般用来初始化。

写法：public 构造方法名(){

//初始化代码

  }

特点：

1、构造方法名必须与类文件名相同

2、构造方法不能有返回值，也不能带void

3、构造方法在对象实例化（new）时被自动调用（这说明它不能被其它类手动调用）

4、构造方法可以根据实际需求带参数（对类属性进行赋值）

5、同一个类中可以存在多个构造方法（重载），但不能有同参

6、同一个类中没有写构造方法时，系统会默认给个无参、无执行块的构造方法，但是一旦自定义了构造方法，系统自带的就会被覆盖。

在对象实例化时，自动调用的构造方法，可以是无参的，也可以是带参的，就看我们怎么用。

如： Student st=new Student();  //实例化，自动调用了Student类中不带参的构造方法

Student st=new Student(100);  //自动调用了Student类中带参的构造方法

五、this关键字

this指向当前类对象

第一种使用：指当前类中的属性和方法：

this.变量名;

this.方法名();

第二种使用：构造函数链

this(); 是指在调用我们的构造函数

---------说白了就是用this调我们的构造函数

public Cat(String name,String sex,String tel,int age){  //a this.name=name; this.sex=sex; this.tel=tel; this.age=age; } public Cat(String name,String sex,String tel){  //b this(name,sex,tel,0); } public Cat(String name,String sex){  //c this(name,sex,null); } public Cat(String name){  //d this(name,null); } public Cat(){  //e this(null); }

/* 执行e时，e调用d，d调用c，c调用b，b调用a

* a最吃亏，最终都是调它；b,c,d,e都是提篮子的。

*/

注意： this用作构造函数调用时，必须放在方法的第一行

六、static关键字

static属于类的东西，出生早于对象，所以即便没有创建对象，也可以调用静态方法。

static加在变量前，变成静态变量；

static加在方法前，变成静态方法；

加了static的变量和方法，除了对象实例化后可调用外，还可以直接通过类调用。

部分规则：

1、静态方法可以直接通过类名调用，任何的对象名（实例）也都可以调用。

2、静态方法中不能用this和super关键字

3、不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。

static静态与非静态区别：

a、非静态的只能用对象名调用, 静态的既能用对象名来调用,又能用类名来调用

b、静态的方法内只能调用静态的方法或者属性，而非静态的方法内部都能调用

c、静态的在对象中间是共享的,只占用一份内存空间

什么情况下我们使用static呢？

当类不能被实例化时（构造方法私有化）

Student s = new Student(); s是对象名  Student是类名

七、单例模式

单例模式：一个类只能被实例化一次。

步骤：

第一步：私有化构造方法，收回实例化权限。

第二步：在类中公开一个代理方法访问私有化构造方法，将这个类做为一个返回值类型返回，同时要将方法静态化，通过类调用这代理方法来创建对象。

Public class A{

Public static A aa = null;

Private A(){}

Public static A createA(){

If(aa ==null){

aa = new A();

}

Return aa;

}

}

八、继承extends

8.1 为什么要继承？

将重复代码抽取到公共类（父类）中，

让其它的类（子类）来调用它，减少代码量。

格式： public  class 子类名 extends 父类{}

父类（基类）和子类（派生类），子类继承了父类，子类就有了使用父类的属性和方法的权限。

访问父类的成员：

super.父类属性;

super.父类方法();

8.2 关于父类的构造方法：

1、子类继承父类后，子类实例化时，先自动执行父类的构造方法，

再执行子类的构造方法；

1. 子类访问父类的构造方法：super();  或  super(参数表);  

只能写在子类构造方法的第一条语句。

8.3 哪些父类的成员，子类是不能被继承？

1、父类中用private声明的属性或方法；

2、父类与子类不在同一个包中，父类使用默认修饰符修饰的属性与方法；

3、父类的构造方法。

8.4 继承初始化顺序：

父类属性 ---》  父类构造方法 ---》  子类属性 ----》 子类构造方法

掌握继承的写法，对父类成员的访问和使用，在项目中使用比较多。

九、包package

同包下，类名不能相同；

跨包状况下，类名的调用：

1、使用跨包的类，则先导入：import  com.base.Malth;  //跨包引用Malth类

2、不导入，直接使用： com.base.Malth  ms=new com.base.Malth();

3、导入多个： import  com.base.*;

十、修饰符

四大修饰符：

private：私有化，最小气的，只能在自己的类中访问；

default|friendly：默认，友好的，只能在自己的类中、同包的类中访问；

protected：受保护的，能在自己的类、

同包的类以及跨包形成父子关系时，子类中也能访问；

public：公共的，最大方的，当前项目中所有的类都可以访问。

修饰符可以修饰类、属性、方法；修饰后，类、属性、方法就可以向上述说的被访问。

十一、方法重写override

1、当子类对于父类的不满意，可以补充，则直接重写父类的方法。

2、删除重写中的super.方法();就是全部推翻父类写法。

3、注意：子类的方法名、返回值、参数必须要与父类保持一致，而访问修饰符只能比父类的要高或者相等

4、重写的方法是否可以重载？可以

Private

Friendly

Protected

public

十二、抽象abstract

抽象：abstract 加在类或方法前面变成抽象类、抽象方法。

①抽象类

不能被实例化，只能作为其它类的基类（父类）。

②抽象方法

--没有方法体；

--必须在子类中被实现（重写），除非子类也是抽象类；

--抽象方法必须位于抽象类中。（换句话说：抽象方法一定要在抽象类中，抽象类中不一定所有的方法都是抽象方法）

抽象方法的由来：只规定对象的行为，不负责实现。（比如猪吃的方法，狗也有吃的方法，基类中写个吃的方法，但是吃什么就不管了。）

十三、里氏替换原则

里氏替换原则：就是用子类实例化的对象去覆盖父类声明的对象。

语法：

父类 对象=new 子类名();

对象的类型是父类。

十四、final常量

final加载类的前面===>该类无法被继承；

final加在方法的前面===>该方法无法在子类当中被重写（可重载吗？）；

final加在变量的前面===>则变成了常量，注意常量大写（无法被修改，必须要有初始化的值）。

常量是变量的一种形式，常量名要全部用大写。

十五、多态

多态：同一种行为在不同的对象上表现出来的不同的形态。

使用多态实现思路：

1.编写父类

2.编写子类，子类重写父类方法

3.运行时，使用父类的类型，子类的对象

十六、接口interface

语法：public interface 接口名

实现多个： public class 类名 implements 接口名1,接口名2...

接口表示的其实是一种能力，接口是对类的抽象（不理解就记下）。

接口里全部都是抽象方法，其它类在实现接口时，都要对接口中的方法进行重写。

编写三步曲：

第一步：定义接口

public interface Myss{//注意，没有class

public void fo();

//上面这个没有加abstract，但是接口默认加上了，不建议写。

}

第二步：实现接口

//实现类

public class Udk implements Myss{

   public void fo(){

System.out.println("实现");

   }

}

第三步：使用接口

//测试类

Myss m=new Udk();  //用里氏替换原则

m.fo();

接口特性：

不能被实例化

实现类必须实现接口的所有方法

实现类可以实现多个接口

接口中的变量都是静态常量

接口中的方法全部是公共的抽象方法

十七、instanceof使用

语法：

    对象 instanceof 类或接口

用来判断一个对象是否属于一个类或者实现了一个接口，结果为true和false；

在强制类型转换之前通过instanceof运算符检查对象的真实类型，可以避免类型转换异常，从而提高代码健壮性。

案例：

Printer pa=new BlackPrinter();

Printer pb=new ColorPrinter();

pa和pb是什么类型？ 是Printer

怎么判断pa和pb是哪种打印机？

if(pa instanceof ColorPrinter){

System.out.println("是彩色打印机");

}else{

System.out.println("是黑色打印机");

}

Public void play(Pet p){

If(p instanceof Dog){

Dog d = (Dog)p;

d.jumpingFireCIrcle();

}

}

Object o = “哈哈哈”;

十八、异常

异常：就是在程序中有可能发生的问题。

对于可能发生问题的代码，我们要进行监控，这就使用到异常。

1、系统异常（看下常见的异常）

语法是：try{//监视

   有可能出现问题的代码

}catch(异常的类型 异常信息所封装成的对象){

   处理异常的代码

}finally{

   最后会被执行的代码（有无异常都会被执行）

}

一个try可以配多个catch，上面的catch不能包含下面的catch

Exception 是所有异常的父类

自定义异常 throws

抛出异常throw

Throws 和 throw 配合使用，同时也要配合try…catch使用。

如给一个方法写了自定义异常，在测试类调这个方法会报错，解决办法，写在try。

对于异常我们应当将其作为一个流程的跳转。

我们在catch中一般来说会用：

1) e.printStackTrace()

   用来查看异常类型以及异常发生的位置

2) e.getMessage()

   只是简单显示异常的信息

System.exit(0)程序正常退出，System.exit(1)非正常退出

十二、常见问题

12.1 方法重写与方法重载的区别

区别	重载overload	覆写(重写)override
概念	方法名称相同、参数的类型及个数不同	方法名称、返回值类型、参数的类型及个数完全相同
范围	一个类	继承关系
限制	没有权限要求	被覆写的方法不能拥有比父类更严格的访问控制权限

12.2 抽象类与接口的区别

12.3 异常的体系是什么？

12.4 访问控制符有哪些，权限有哪些？