java面向对象总结_java面向对象总结

前言：文章参考《java疯狂讲义》进行总结和归纳，知识要进行输出才算真正的有用。

在java的世界里，一切皆为对象，类是对对象的抽象，来一个例子：Person类

public class Person{

//类的结构分为3部分：属性、构造器、方法//1.属性 定义方式：权限修饰符+类型+变量名public String name;

public Int age;

public String address;

/**2.构造器 构造器，是创建对象时的构造函数，*作用是可以给对象进行初始化，创建对象都必须要通过构造函数初始化要求名称必须与类名相同*一个类中如果没有定义过构造函数，那么该类会有一个默认的空参数构造函数。*如果在类中定义了指定的构造函数，那么该类中的默认构造函数就没有了*/

public Person(String name,Int age,String address){

this.name = name;

this.age = age;

this.address = address;

}

/**3.方法 格式：修饰符+方法名(驼峰命名)+参数列表*3.1权限修饰符：public.protected,private,default*public所有都能访问*protected同一个类同一个包及子类*default同一类同一个包*private同一个类*3.2静态修饰符：*static(类方法，静态方法，可以不创建对象被类直接调用)*静态方法会随着类的定义而被分配和装载入内存中，*静态方法可以调用静态方法以及访问静态数据域，*但静态方法不能调用实例方法或者访问实例数据域。*/

public void eat(){

System.out.println("人喝水");

}

public static void breath(){//静态方法System.out,println("人呼吸");

}

}

有了类，就可以创建者个类的对象了，语法如下：

Person p1 = new Person("tom",9,"Beijing");//创建对象

p1.eat();//调用方法

java的三个特点是：继承、封装、多态，都是和面向对象有关系的，下面进行解释

1 继承

继承就是子类继承父类的特征和和行为，使得子类对象(实例)具有父类的实例域和方法，还可以以此基础添加新方法和域来满足需求，举个例子：

Person类是父类，那么Student类是子类(学生是人，满足is-a关系)，java规定一个子类只能拥有一个父类，子类对象实例化时一定先实例化父类对象。

public class Person{//父类

}

//子类继承父类

public class Student extents Person{

}

特点：提高代码复用性、父类的属性方法可以用于子类、 可以轻松的定义子类、 使设计应用程序变得简单。

注意事项：只支持单继承，即一个子类只允许有一个父类，但是可以实现多级继承，及子类拥有唯一的父类，而父类还可以再继承。​ 子类可以拥有父类的属性和方法。​ 子类可以拥有自己的属性和方法。​ 子类可以重写覆盖父类的方法。

继承的使用：

a，直接通过子类对象访问成员变量

​ 等号左边是谁，就优先使用谁，如果没有就向上找。

b，间接通过成员方法访问成员变量

该方法属于谁，谁就优先使用，如果没有就向上找。

public class FU {

int numFU = 10;

int num = 100;

public void method(){

System.out.println("父类成员变量："+numFU);

}

public void methodFU(){

System.out.println("父类成员方法!");

}

}

public class Zi extends FU{

int numZi = 20;

int num = 200;

public void method(){

System.out.println("子类成员变量："+numFU);

}

public void methodZi(){

System.out.println("子类方法！");

}

}

public class ExtendDemo {

public static void main(String[] args) {

FU fu = new FU();

// 父类的实体对象只能调用父类的成员变量

System.out.println("父类：" + fu.numFU); // 结果：10

Zi zi = new Zi();

System.out.println("调用父类：" + zi.numFU); // 结果：10

System.out.println("子类：" + zi.numZi); // 结果：20

/** 输出结果为200，证明在重名情况下，如果子类中存在则优先使用，

* 如果不存在则去父类查找，但如果父类也没有那么编译期就会报错。

*/

System.out.println(zi.num); // 结果：200

/**

* 通过成员方法调用成员变量

*/

zi.method(); // 结果：10

}

}

​成员方法也是一样的，创建的对象是谁，就优先使用谁，如果没有则直接向上找。

注意事项：​ 无论是成员变量还是成员方法，如果没有都是向上父类中查找，绝对不会向下查找子类的

在继承关系中，关于成员变量的使用：​

局部成员变量：直接使用

本类成员变量：this.成员变量

父类成员变量：super.父类成员变量

2 封装

封装(Encapsulation)是面向对象方法的重要原则，就是把对象的属性和操作(或服务)结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

特点：对成员变量实行更准确的控制，封装可以隐藏内部程序实现的细节，良好的封装能够减少代码之间的耦合度，外部成员无法修改已封装好的程序代码，方便数据检查，有利于保护对象信息的完整性，同时也提高程序的安全性，便于修改，体高代码的可维护性

使用：使用private修饰符，表示最小的访问权限；对成员变量的访问，统一提供setXXX，getXXX方法

public class Student implements Serializable {

private Long id;

private String name;

private Integer sex;

public Long getId() {

return id;

}

public void setId(Long id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getSex() {

return sex;

}

public void setSex(Integer sex) {

this.sex = sex;

}

}

3 多态

多态是同一个行为具有多个不同表现形式或形态的能力。

特点：消除类型之间的耦合关系，实现低耦合；灵活性；​ 可扩充性；​ 可替换性

使用：

public class MultiDemo {

public static void main(String[] args) {

// 多态的引用，就是向上转型

Animals dog = new Dog();

dog.eat();

Animals cat = new Cat();

cat.eat();

// 如果要调用父类中没有的方法，则要向下转型

Dog dogDown = (Dog)dog;

dogDown.watchDoor();

}

}

class Animals {

public void eat(){

System.out.println("动物吃饭！");

}

}

class Dog extends Animals{

public void eat(){

System.out.println("狗在吃骨头！");

}

public void watchDoor(){

System.out.println("狗看门！");

}

}

class Cat extends Animals{

public void eat(){

System.out.println("猫在吃鱼！");

}

}

向上转型：1，格式：父类名称 对象名 = new 子类名称();

含义：右侧创建一个子类对象，把它当作父类来使用。

注意：向上转型一定是安全的。 缺点：一旦向上转型，子类中原本特有的方法就不能再被调用了。