一、OOP的概念
OOP(Object Oriented Programming):面向对象编程
二、类与对象
类(class)和对象(object)是OOP的两大核心概念
1.类
类(class)定义了一件事物的抽象特点,也就是定义了事物的属性和行为。比如 “人” 这个类就会包含一切人的特征与行为,姓名、年龄、性别等特征与说话、走路等行为。
Tips:类是对某一事物的描述,是抽象的,概念上的定义。类是一个模板,它描述了一类对象的行为和属性。
(1)定义一个类
格式:
class 类名{
...
}
Example:
//定义一个类,类名:Person,代表 “人”
class Person{
...
}
(2)定义类的成员(属性(变量)与行为(方法))
每个事物都有自己的属性和行为,我们把它们抽象出来定义到类里面,其中属性是个值,定义为变量(成员变量),行为是个动作,定义为方法。
(a)定义类的成员变量(属性)
例如我们把 “人” 这个事物的属性抽象的提取出来,他们都有 “名字”、“性别”、“年龄”,但是重点是没有具体指是哪个人,所以定义的变量都是没有值。
Example:
class Person{
String name;//姓名
String sex;//性别
int age;//年龄
}
(b)定义类的方法(行为)
例如“人” 会 “说话” ,所以把 “说话” 这个行为提出出来
Example:
class Person{
String name;//姓名
String sex;//性别
int age;//年龄
private void speak(String name, String sex, int age){
System.out.println("我叫" + name + ",我的性别是" + sex + ",我" + age + "岁了。" );
}
}
1.对象(object)
对象是类的一个实例(并不是找对象的那个对象),有行为和属性。例如一个人就是一个对象,他的属性有:姓名、性别、年龄;行为有:说话、走路等。
Tips:对象是实际存在的该事物的个体,是具体的,现实的。JAVA中有句话:万物皆对象(感觉有点唯物主义色彩)
(1)创建一个对象
对象是根据类创建的。在Java中,使用关键字new来创建一个新的对象。创建对象分三步:
声明:声明一个对象,包括对象名称和对象类型。
实例化:使用关键字new来创建一个对象。
初始化:使用new创建对象时,会调用构造方法初始化对象。(每个类都有构造方法。如果没有显式地为类定义构造方法,Java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候,至少要调用一个构造方法。构造方法的名称必须与类同名,一个类可以有多个构造方法)
Example:
class Person(){
pulic Person(){
//默认构造方法
}
public static void main(Stirng[] args){
//创建一个Person对象
Person person = new Person();
}
}
(2)调用对象的成员变量和方法
Example:
public class PersonTest(){
public static void main(String[] args){
Person person = new Person();//创建一个Person对象
person.name = "小明";//访问这个对象的成员变量name,并给它赋值为"小明"
person.sex = "男";//访问这个对象的成员变量sex,并给它赋值为"男"
person.age = 20;//访问这个对象的成员变量age ,并给它赋值为20
person.speak(person.name, person.sex, person.age);//调用这个对象的方法speak,给它传值为这个对象的成员变量name、sex、age
}
}
三、封装、继承、多态
1.封装
将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问,常见的比如 getter、setter方法。
封装遵循了 “开闭原则”,禁止外部直接访问和修改类的信息。
封装的优点:
● 1. 良好的封装能减少耦合。
● 2. 类内部结构可以自由修改。
● 3. 可以对成员变量进行更精确的控制。
● 4. 隐藏信息,实现细节。
Example:
java封装类:
public class Person {
private String name;
private String sex;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
访问与修改:
public class PersonTest {
public static void main(String[] args) {
Person person = new Person();
person.setName("小明");
person.setSex("男");
person.setAge(20);
System.out.println("Name : " + person.getName() + " Sex: " + person.getSex() + " Age: " + person.getAge());
}
}
输出结果为:
2.继承
继承就是类与类之间的一种关系,子类继承父类的方法与变量(非private修饰符修饰),减少代码冗杂,提高代码复用性。
继承格式:
class 父类 {
}
class 子类 extends 父类 {
}
继承类型:
继承的特征:
● 1. 子类拥有父类非private方法,属性。
● 2. 子类可以拥有自己的方法和属性,即子类可以对父类进行拓展。
● 3. 子类可以用自己的方式实现父类的方法。
● 4. Java的继承是单继承,但是可以多重集成,单继承就是一个子类只能集成一个父类,多重继承就是A继承B,B继承C,所以C就是B的父类,B就是A的父类。
● 5. 提高了类之间的耦合性也就是继承的缺点,耦合度高会造成代码之间的联系紧密,独立性差。
继承关键字
extends与implements两个关键字,当一个类没有继承的这俩关键字的时候,则默认继承Object类(所有的类都是继承自Object)
(1)extends关键字
在java中,类的继承是单一继承,就是一个子类只能拥有一个父类,所以extends关键字只能继承一个类。
Example:
public class Person {
private String name;
private int age;
public void eat(){
//吃东西方法的具体实现
}
public void sleep(){
//睡觉方法的具体实现
}
class WoMan extends Person{
}
}
(2)implements关键字
使用implements关键字可以变相的使Java具有多继承的特性,使用范围为类继承接口,可以同时实现多个接口(接口之间用逗号间隔)。
Example:
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}
(3)super和this关键字
super关键字:通过super关键字实现对父类的访问,用来引用当前对象的父类。
this关键字:指向自己的引用。
Example:
public class Person {
private void eat() {
System.out.println("父类方法");
}
static class Woman extends Person {
private void eat() {
System.out.println("子类方法");
}
private void test() {
super.eat();
this.eat();
}
}
public static void main(String[] args) {
Person person = new Person();
person.eat();
Woman woman = new Woman();
woman.test();
}
}
输出结果为:
(4)final关键字
final关键字声明的类可以把类定义成不可被继承的,即最终类;或者用于修饰方法,该方法不能被子类重写。
注:变量也可以被声明为final,被定义成final的变量不能被修改。被声明为final类的方法自动地声明成final,但是变量不是final。
3.多态
多态是同一个行为具有多个不同表现形式活形态的能力。
多态的优点:
● 1. 消除类型之间的耦合关系。
● 2.可替换性。
● 3.可扩充性。
● 4. 接口性。
● 5. 灵活性。
● 6. 简化性。
多态存在的三个必要条件:
● 继承
● 重写
● 父类引用指向子类对象
比如:
Parent p = new Child();
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译报错;如果有,再去调用子类的同名方法。多态的好处:可以使程序有良好的拓展性,并可以对所有类的对象进行通用处理。
Example:
public class Test {
public static void main(String[] args) {
show(new Cat());// 以 Cat 对象调用 show 方法
show(new Dog());// 以 Dog 对象调用 show 方法
Animal animal = new Cat();//向上转型
animal.eat();//调用的Cat的eat
Cat cat = (Cat) animal;//向下转型
cat.work();//调用的Cat的work
}
public static void show(Animal animal) {
animal.eat();
//类型判断
if (animal instanceof Cat) {//猫做的事情
Cat cat = (Cat) animal;
cat.work();
} else if (animal instanceof Dog) {//狗做的事情
Dog dog = (Dog) animal;
dog.work();
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
}
运行结果: