华清远见-重庆中心-JAVA面向对象阶段技术总结

华清远见-重庆中心-JAVA面向对象阶段技术总结

面向对象和面向过程的编程思想

面向对象（OOP）

通过创建（new）对象，赋予对象对应的行为和特征，让这些对象相互配合来解决问题

面向过程（POP）

分析解决问题所需要的步骤，通过函数依次实现这些步骤来解决问题

类和对象

类 Class

**具有相同属性和行为的对象的集合，称为"一类"。**可以理解为模板。

**属性：**描述对象的特征，在程序中，通过定义变量的形式表现属性。

**行为：**描述对象的动作，在程序中，通过定义方法的形式表现行为。

在程序中，通过定义一个class来定义一个类。在类中定义变量描述属性，定义方法描述行为。

定义类

[修饰符] class 类名{

//属性(变量)

//行为(方法)

}

public class Person {
    /*
    * 定义属性，如：
    * 姓名
    * 性别
    * 年龄
    * */
    String name;
    String sex;
    int age;

    /*
    * 定义方法，如：
    * 吃饭
    * 睡觉
    * 打豆豆
    * */
    public void eat(){
        System.out.println("吃饭");
    }

    public void sleep(){
        System.out.println("睡觉");
    }

    public void BeatBeans(){
        System.out.println("打豆豆");
    }
}

对象 Object

对象是类的一个实例

创建对象

类名 对象名 = new 构造方法（[参数]）；

public class Father {
    public static void main(String[] args) {
        //创建对象初始化
        Person person=new Person();
        //调用person对象中的属性并赋值
        person.name="张三";
        person.sex="男";
        person.age=20;
        
        //调用person对象中的方法
        person.eat();
        person.sleep();
        person.BeatBeans();
    }
}

方法

调用

一段独立的代码，**通过类名或方法使用操作符“.”进行调用。**可以被重复调用。

自定义方法

修饰符 返回值类型 方法名(参数类型 参数名,参数类型 参数名...){
方法体
}

**返回值类型：**可以是原始数据类型也可以是引用数据类型，还可以没有返回值，但要注明：void。返回值不为void时，方法结束前需要使用return返回对应的结果。

**参数类型和参数名：**参数类型可以是数据类型，也可以是类名；参数类型和参数名可以不写，此时参数列表无参数。

方法的分类

• 无返回值无参数
• 无返回值有参数
• 有返回值无参数
• 有返回值有参数

成员变量、局部变量、静态常量

**成员变量：定义在类中的变量，即类的属性。**它有默认值。通过对象访问。

**局部变量：定义在方法中的变量。**它没有默认值。只能在方法中赋值后才能使用。

静态常量：特殊的成员变量，用final static修饰。它有默认值。通过类名访问。

class Person{
//成员变量
String name;
//静态常量
final static String COUNTRY="中国";
//定义方法
void info(){
//局部变量
int age=30;
System.out.println("我叫"+name+"，今年"+age+"岁，是一个"+COUNTRY+"人");
}
}

构造方法

是一种特殊的方法。方法名和类名一致。通常用于限制创建对象时携带的参数，并初始化成员变量。没有返回值。

public class Person{
    
    //定义一个构造方法，不定义也有一个默认的，不过隐藏了
    //访问修饰符 类名（）{}
    public Person(){
        
    }
}

注意：

1. 未在类中定义无参构造方法和有参构造方法时，**会默认有一个隐藏的无参构造方法。**定义了有参构造方法时，默认隐藏的无参构造方法就会消失，如果需要无参构造方法，需要重新定义一个。
2. **执行构造方法不一定会创建对象。**比如抽象类有构造方法，但是在调用时无法创建抽象类对象，只能在创建抽象类的子类对象时，自动调用抽象类的构造方法。
3. 构造方法不能重写。

public class Person {
    //定义有参构造方法
    public Person(int name){
        System.out.println(name);
    }
    
    //前面定义了有参构造方法，若还需要无参构造方法，则需要重新定义一个
    public Person(){
        
    }
}

面向对象三大特性——封装、继承、多态

封装

用private对类或属性进行修饰，可以防止非当前类的访问。

封装的步骤

1. 给类中的所有属性添加private访问修饰符
2. 给每个属性添加get方法名（）方法用于读取属性值
3. 给每个属性添加set方法名（）方法用于给属性赋值

生成getter and setter快捷键：alt+insert

继承

继承的分类

1. 继承类：类A extends 类B，即B是A的父类。此时，类A可以访问父类所有的非私有成员。
2. 继承接口：接口A extends 接口B。
3. 实现接口类：类A implements 类B，即类A是接口B的实现类。

注意：

1. Object类是所有类的父类。
2. java是单继承，但是允许多重继承。

重写 Override

子类继承父类后，对父类的非私有方法进行重写，达到拓展或重做的目的。抽象父类的抽象方法必须重写，除非子类也定义为抽象类。

生成Override快捷键：ctrl+o

特点：

• 必须满足方法名、返回值、参数列表都相同
• 访问权限不能比父类中的方法更严格
• 不能抛出比父类中的方法更大的异常

重载 Overload

在一个类中，同一个方法在不同参数下，表现出不同的行为，即同名不同参。

生成Overload快捷键：ctrl+o

特点：

• 被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

this和super

都可以当做对象或构造方法使用。

**当作对象时：**this表示当前类的对象，super表示当前类的父类对象。this和super当作对象时只能用在非静态方法中。

**当做构造方法：**this（）表示当前类的无参构造方法，如果带参数则表示对应参数的构造方法。super（）表示当前类的父类的无参构造方法，如果带参数则表示对应参数的构造方法。

注意：

• this（）和super（）只能用在另一个构造方法的首行。

• 在继承关系中，如果父类和子类都没有写出来任何构造方法时，子类有一个隐藏的无参数构造方法，会自动调用父类中无参数的构造方法。

//创建父类Father
public class Father{

}
//创建子类
public class Son extends Father{
    /*
    这个构造方法是隐藏的
    */
    public Son(){
        super.();
    }
}

• 如果父类中有有参构造方法，没有无参构造方法时，子类必须要调用父类中的构造方法。

class Father{
	String name;
	public Father(String name){
		this.name=name;
	}
}
class Son extends Father{
	public Son(){
		super("xxx");
	}
}

多态

子类的对象可以保存在父类的变量中。多态通常应用于定义方法时，形参为一个父类或接口类型变量，实参可以是子类对象。

public class Father{
	public void drink(){
	System.out.println("father drinking");
	}
}
public class Son extends Father{
	public void play(){
		System.out.println("son playing");
	}
	@Override
	public void drink(){
	System.out.println("son drinking");
	}
}
public class Main(){
	public static void main(String[] args){
		Father f = new Father();
		f.drink();//父类中的方法
		Son son = new Son();
		son.play();
		son.drink();//调用的是重写后的方法
		//多态
		Father father = new Son();
		//father.play();无法调用
		father.drink();//调用的是重写后的方法
	}
}

关键字

final

可以修饰类、方法、属性。

• 修饰类：类为最终类，不能被继承。
• 修饰方法：方法为最终方法，不能重写。
• 修饰属性：属性变更为常量，不能改变数值。

abstract

可以修饰类和方法。

特点：

• 修饰类时，类变为抽象类。
• 修饰方法时，方法变为抽象方法，没有方法体。
• 抽象类可以有构造函数，但该构造方法只会在new抽象类的子类对象时自动调用。
• 抽象类中的方法不一定都是抽象方法，也可以是普通方法。
• 非抽象类子类继承抽象类时，必须重写父类的所有抽象方法。
• 有抽象方法的类必须用abstract关键词修饰成为抽象类。

interface

定义接口的关键字。代替class。

如果某个抽象类中全是抽象方法时，可以将该类定义为接口。

特点：

• 接口是一个完全抽象类，其中的方法都是public abstract修饰的抽象方法，没有方法体，其中的属性都是public final static修饰的静态常量。
• 接口中没有构造方法，不能创建对象。
• 接口通过implements实现，实现它的类称为该接口的实现类。
• 一个类可以同时实现多个接口（不同于类与类之间的单继承），实现多继承。
• 一个类实现了接口后，必须重写其中的抽象方法。
• JDK1.8后，**可以在接口中定义default方法和static方法，**该方法不用重写。

//类A是类B的子类，是接口C，D的实现类
public class A extends B implements C，D{
    
}

static

可以修饰属性、方法或代码块。被修饰的内容称为静态成员。

注意：

• 静态方法中无法使用非静态成员。
• 普通方法中可以使用静态成员。
• 静态成员可以直接通过类名访问，不用调用对象。