大纲"/>
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、子类继承父类后,子类实例化时,先自动执行父类的构造方法,
再执行子类的构造方法;
- 子类访问父类的构造方法: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 访问控制符有哪些,权限有哪些?
更多推荐
OOP大纲
发布评论