1、封装
代码案例:
//封装
public class Demo_Encapsulation {
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;
}
private String name;
private int age;
}
1.1、封装的概述
1、封装是面向对象三大特征之一(封装、继承、多态)
2、是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是无法直接操作和访问的
1.2、封装原则
1、将类的某些信息隐藏在内部,不允许外部程序直接访问,二十通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private,提供对应的getXxx()/serXxx()方法
1.3、封装的好处
1、通过方法来控制成员变量的操作,提高了代码的安全性
2、把代码用方法进行封装,提高了代码的复用性
2、继承
代码案例:
//父类
public class Fu {
public int number;
public void age(){
System.out.println("父亲今年多少岁");
}
//子类
public class Zi extends Fu{
//重写父类的方法
@Override
public void age() {
System.out.println("儿子今年多少岁"+number+"岁");
}
//测试类
public class Test {
public static void main(String[] args) {
Fu zi = new Zi();
zi.age();
}
1.1、 继承的概述
1、继承的格式
格式:public class 子类名 extends 父类名{}
范例:public class Zi extends Fu {}
Fu: 是父类,也被称为基类、超类
Zi: 是子类,也被称为派生类
1.2 、继承的好处和弊端
1、继承的好处
提高了代码的复用性(多个类相同的成员可以放到同一个类中)
提高了到吗的维护性(如果方法的代码需要修改,修该一处即可)
2、继承的弊端
继承让类与类之间产生了关系,类的耦合性增强了,但父类发生变化时子类实现也不得不跟着变化,削弱了子类的独立性
3、什么时候使用继承?
继承体现的关系:is a
假设法:我有两个类A和B,如果他们满足A是B的一种,或者说B是A的一种,就说名明它们存在继承关系,这个时候就可以考虑使用继承来体现,否则就不能滥用继承
举例:苹果和水果,猫和动物
1.3、继承中变量的访问特点
1、在子类方法中访问一个变量
在子类局部范围找
在子类成员范围找
在父类成员范围找
如果都没有就报错(不考虑父亲的父亲...)
1.4、super
1、super关键字用法和this关键字的用方法相似
this:代表本类对象的引用
super:代表父类存储空间的标识(可以理解为父类对象的引用)
关键字 | 访问成员变量 | 访问构造方法 | 访问成员方法 |
---|---|---|---|
this | this.成员变量 访问本类成员变量 | this(...) 访问本类构造方法 | this.成员方法(...) 访问本类成员方法 |
super | super.成员变量 访问父类成员变量 | super(...) 访问父类构造方法 | super.成员方法(...) 访问父类成员方法 |
1.5、继承中构造方法的访问特点
1、子类中所有的构造方法默认都会访问父类中无参的构造方法
为什么呢?
因为子类会继承父类父类中的数据,肯恶搞怀惠使用父类的数据。所以,子类初始之前,一定先完成父类数据的初始化
每一个子类构造方法的第一条语句默认都是:super()
2、如果父类中没有无参构造方法,只有带参构造方法,该怎么办呢?
通过使用super关键字去显示的调用父类的带参构造方法
在父类中自己提供一个无参构造方法
推荐:自己给出无参构造方法
1.6、继承中成员方法的访问特点
1、 通过子类对象访问一个方法
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲)
1.7、方法重写
1、方法重写的概述
子类中出现类和父类中一模一样的方法声明
2、方法重写的应用
当子类需要父类的功能,而功能主体子类有自己特有的内容时,可以重写父类中的方法,这样,纪颜希呢父类的功能,又定义了子类特有的内容
3、@Override
是一个注解
可以帮助我们检查重写方法的方法声明的正确性
4、方法重写的注意事项
私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低(public>默认>私有)
1.8、访问修饰符
修饰符 | 同一类中 | 同一包中子类无关类 | 不同包的子类 | 不同包的无关类 |
private | √ | |||
默认 | √ | √ | ||
protected | √ | √ | √ | |
public | √ | √ | √ | √ |
目录
3、 多态
代码实例:
//动物类
public class Animal {
public void eat(){
System.out.println("动物吃东西");
}
//猫类
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃东西");
}
//测试类
public class AnimalTest {
public static void main(String[] args) {
//父类引用指向子类对象
Animal a=new Cat();
}
1.1、多态概述
1、同一对象,在不同时刻表现出来的不同形态
2、多态的前提
有继承/实现关系
有方法重写
有父类引用指向子类对象
1.2、多态中成员访问特点
1、成员变量:编译看左边,执行看左边
2、成员方法:编译看左边,执行看右边
为什么成员变量和成员方法的访问不一样呢?
答:因为成员方法有重写,而成员变量没有。
1.3、多态的好处和弊端
1、 多态的好处:提高了程序的扩展性
具体体现:定义方法的时候,将父类型作为参数,将来使用的时候,使用具体的子类型参与操作
2、多态的弊端:不能使用子类的特有功能
1.4、多态中的转型
1、向上转型
从子到父
父类引用指向子类对象
2、向下转型(可以解决多态的弊端 )
从父到子
父类引用转为子类对象
4、 抽象类
代码案例:
//动物类
public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = 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;
}
public abstract void eat();
//猫类
public class Cat extends Animal {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
//测试类
public class AnimalTest {
public static void main(String[] args) {
//创建对象,按照多态的方式
Animal a = new Cat();
a.setName("加菲");
a.setAge(5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
System.out.println("--------");
a = new Cat("加菲",5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
}
1.1、抽象类的概述
在Java中,一个没有方法体的 方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。
1.2、抽象类的特点
1、抽象类和抽象方法必须使用abstract关键字修饰
public abstract class 类名{...}
public abstract void 方法名{...}
2、抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
3、抽象类不能被实例化
抽象类如何实例化呢?参照多态的方式,通过子类对象实例化,这叫抽象类多态
4、抽象类的子类
要么重写抽象类中所有的抽象方法
要么是抽象类
1.3、抽象类的成员特点
1、成员变量
可以是变量
也可以是非变量
2、构造方法
有构造方法,但是不能被实例化
那么,构造方法的作用是什么呢?是用于子类访问父类数据的初始化
3、成员方法
可以有抽象方法:限定子类必须完成某些动作
也可以有非抽象方法:提高代码复用性
5、接口
代码案例:
/接口
public interface Inter {
public int num=10;
public abstract void show();
}
public class InterImpl extends Object implements Inter{
public InterImpl() {
}
@Override
public void show() {
System.out.println("show");
}
}
//测试类
public class InterfaceDemo {
public static void main(String[] args) {
Inter i=new InterImpl();
System.out.println(i.num);
}
}
1.1、接口概述
接口就是一种公共的规范标准,只要符合规范标准,大家都可以通用Java中的接口更多体现对行为的抽象
1.2、接口的特点
1、接口用关键字interface修饰
public interface 接口名{...}
2、类实现接口用implements表示
public class 类名 implements 接口名{...}
3、接口不能实例化
接口如何实例化呢?参照多态的方式,通过实现类对象实例化,这叫接口多态。
多态的形式:具体类多态,抽象多态,接口多态。
多态的前提:有继承或者实现关系;有方法重写;有父(类/接口)引用指向(子/实现)类对象
4、接口的实现类
要么重写接口中所有抽象方法
要么是抽象类
1.3、接口的成员特点
1、成员变量
只能是常量
默认修饰符:public static final
2、构造方法
接口没有构造方法,因为接口主要是对行为进行抽象的,是没有具体存在。
一个类如果没有父类,默认继承Object类
3、成员方法
只能是抽象方法
默认修饰符:public abstract
1.4、类和接口的关系
1、类和类的关系
继承关系,只能单继承,但是可以多层继承
2、类和接口的关系
实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口
3、接口和接口的关系
继承关系,也可以单继承,也可以多继承
1.5、抽象类和接口的区别
1、成员区别
抽象类:有变量、有常量、有构造方法、有抽象方法,也有非抽象方法
接口: 常量、抽象方法
2、关系区别
类与类: 继承——单继承
类与接口: 实现——可以单实现,也可以多实现
接口与接口:继承——单继承,多继承
3、设计理念区别
抽象类: 对类抽象,包括属性、行为
接口: 对行为抽象,主要是行为