- 一.面向对象语言的三大特征---封装
- 1.封装的概念
- 2.封装的好处
- 3.设计模式
- 单例模式
- 1.懒汉单例
- 2.饿汉单例(急切式单例)
- 二.面向对象语言的三大特征---继承
- 1.什么是继承
- 2.什么时候使用继承
- 3.几个名词
- 4.继承的传递性
- 5.注意事项
- 6.继承中的构造方法
- super关键字
- 继承中的构造方法
- 7.方法的重写(OverRide)
- 1.何时需要方法重写
- 2.如何重写方法
- 3.方法重写规则
- 三.抽象类
- 1.抽象方法
- 1.什么是抽象方法
- 2.什么时候需要抽象方法
- 2.抽象类
- 1.什么是抽象类
- 2.抽象类特点
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问 .
2.封装的好处1.隐藏类的细节
2.只能通过规定方法访问
3.方便加入控制语句
4.方便修改实现
//属性私有化就是封装的一种表现
package morning ;
public class SingLeton {
private String a;
public String getA() {
return a;
}
public void setA(String a) {
if(a != "qq") {
this.a = a;
}
}
}
3.设计模式
设计模式:前人总结出解决某些问题的最佳方案
单例模式需要某一个类在整个应用程序中,只能创建一个对象.
解决思路:
第一步:将构造方法私有化,使得在程序其他地方不能随意创建对象.
第二步:向外界提供一个方法,用来获得创建的唯一一个对象,在类的内部控制起来比较方便.
1.懒汉单例程序如下:
package morning ;
//实现只能创建一个对象,
// 懒汉单例
public class SingLeton {
private static SingLeton singLeton;//私有的静态SingLeton变量.私有的变量将其封装起来.因为在创建对象前要进行判断,因此需要static
//将构造方法私有化
private SingLeton(){
}
public static SingLeton get(){
if(singLeton == null){//如果未进行初始化
singLeton = new SingLeton();//创建对象,赋给地址
}
return singLeton;
}
}
懒汉单例存在线程安全问题.
2.饿汉单例(急切式单例)程序如下:
package morning;
//饿汉单例(急切式单例)
public class SingLeton1 {
//创建一个对象,因为是静态,只加载一次,储存在方法区
static SingLeton1 singLeton = new SingLeton1();
//构造方法私有化
private SingLeton1(){
}
//向外界提供得到指向对象的变量方法
public static SingLeton1 getSingLeton(){
return singLeton;
}
public static void main(String[] args) {
System.out.println(SingLeton1.getSingLeton());
}
}
饿汉单例不存在线程安全问题.
二.面向对象语言的三大特征—继承 1.什么是继承继承是面向对象程序设计不可缺少的设计思想,是实现代码可重
用的根基,是提高代码可扩展性的主要途径.
继承是从已有的类中派生出新的类,新的类能吸收已有类的属性和行为(重用性),并能扩展新的能力(扩展性).
2.什么时候使用继承符合**[is-a]**的关系就可以使用继承
比如:猫是动物,狗是动物.那么猫和狗就可以继承于动物类.
动物类就是猫类和狗类的父类.在创建的时候,将子类共有的属性和行为放在父类中.
ackage afternoon;
public class Animal {
private String name;
private int age;
//无参的构造方法
public Animal(){
}
//共有的行为
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
//提供可修改的方法
public void show(){
System.out.println(name+age+"岁");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package afternoon;
public class Cat extends Animal{
}
ackage afternoon;
public class Test {
public static void main(String[] args) {
Cat cat = new Cat();
cat.setName("大黑");
cat.setAge(9);
cat.sleep();
cat.eat();
cat.show();
}
}
继承是代码重用的一种方式.
3.几个名词就如上面的两段代码
猫类是动物类的子类,动物类是猫类的父类.
猫类是动物类的派生类,动物类是猫类的基类.
4.继承的传递性C类从B类继承,B类又从A类继承.
那么C类就具有B类和A类的所有非私有属性和非私有方法.
在上面代码的基础上我们继续添加一个类继承猫类
package afternoon;
public class Mimi extends Cat{
private String color;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
package afternoon;
public class Test {
public static void main(String[] args) {
Mimi mimi = new Mimi();
mimi.setColor("黄色");
System.out.println(mimi.getColor());
mimi.setName("小米 ");
mimi.setAge(6);
mimi.show();
}
}
5.注意事项
1.当一个没有继承任何一个类时,jvm会默认让类继承**Object类,**Object类是Java为所有类提供的基类.
2.在Java中使用extends关键字来表示继承关系.
3.Java不支持多继承,单继承使得Java的继承关系很简单,一个类只能有一个直接父类.
4.继承之后子类可以调用父类的所有非私有属性和非私有方法.
6.继承中的构造方法 super关键字super关键字的用途:
(与this相对应,this代表的是当前对象.super代表的是父类的.)
我们可以使用super关键字访问父类成员
1.使用super.成员变量名来引用父类成员变量
2.使用super.方法名(参数列表)访问父类的方法
3.使用super.构造方法(参数列表)访问父类构造方法
注意事项:
不要误认为super是父类对象,在创建子类对象时,不会创建父类对象.只会把父类的信息加载到子类对象中存储.
继承中的构造方法子类构造方法会先调用父类构造方法.
使用super关键字调用父类任意一个构造方法,必须写在第一行.
为什么必须写到第一行 因为子类创建对象后,子类可以访问父类的信息.也就是说new这个动作执行后,有可能对其中的属性做出了操作.所以在初始化子类之前,必须先初始化父类.也就是先调用父类的构造方法.
如果子类的构造方法中没有显式的调用父类构造方法,则系统默认在子类构造方法第一行调用父类无参数的构造方法.
7.方法的重写(OverRide)重写也叫覆盖或者复写.
1.何时需要方法重写当父类的方法实现不能满足子类需求时,可以对方法进行重写
2.如何重写方法在子类中可以根据需要对从父类继承来的方法进行重写
public void eat(){
System.out.println("吃饭");
}
@Override//@Override标签表示此方法是重写的
public void eat(){
System.out.println("猫吃饭");
}
这就是重写方法
3.方法重写规则1.方法名相同,参数列表相同
2.返回值类型相同
3.访问权限不能小于父类权限
注意:
构造方法,静态方法不能重写,成员变量不存在重写
三.抽象类 1.抽象方法 1.什么是抽象方法抽象方法是一种特殊的方法:只有声明,没有具体的实现.
例如: public abstract void eat();//抽象的方法
抽象方法必须用abstract来修饰.
2.什么时候需要抽象方法可能有很多子类的行为与父类的行为不同.比如说吃,有的吃肉,有的吃草…那么在父类定义的吃的行为就很多余,因为在子类还需要重写.这个时候就可以对方法进行抽象.
抽象方法没有方法体,如果有抽象方法,需要将类定义为抽象类.
2.抽象类 1.什么是抽象类如果一个类中没有包含足够的信息来描绘一个具体的对象(也就是有抽象方法),这样的类就是抽象类.
注意:抽象类不一定有抽象方法.有抽象方法一定是抽象类.
抽象类除了不能实例化对象之外(因为有抽象方法不能实例化),类的其他功能依然存在,成员方法,成员变量,构造方法…
如我们提到的动物类
package afternoon.chouxiang;
public abstract class Animal {//抽象的类
private String name;
private int age;
public abstract void eat();//抽象的方法
public void sleep(){
System.out.println("躺着睡觉");
}
public Animal(){
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
**用abstract修饰的类就是抽象类.**如果某个类包含抽象方法,那么该类必须定义为抽象类.
2.抽象类特点**抽象类不能被实例化.但可以有构造方法.**因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象.
抽象类只能用作基类,表示的是一种继承关系.继承抽象类的非抽象类必须实现其中的所有抽象方法,而已实现方法的参数、返回值要和抽象类中的方法一样.否则,该类也必须声明为抽象类.
比如:
package afternoon.chouxiang;
//狗类继承动物类,要么将狗类也抽象化,要么对抽象方法进行重写
public class Dog extends Animal{
@Override
public void eat(){
System.out.println("狗会吃饭");
}
}
抽象类,抽象方法,在软件开发过程中都是设计层面的概念.也就是说,设计人员会设计出抽象类,抽象方法.程序员都是继承这些抽象并覆盖抽象方法,实现具体功能.



