版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/lclsj479/article/details/96205767

面向对象

构造器

构造器的用法

在类中用来创建对象那个的方法称之为构造器 构造函数 构造方法

1：构造器是一个特殊的方法：

a：构造器（方法）名称和类名相同。

b：构造器（方法）无返回值。

c：在方法中无需写return返回数据。

d：构造器是允许方法重载的。

e：所有类默认情况下都会存在一个无参构造器，如果在当前类中显式的声明了构造器之后，无参构造器就不存在了。

构造器的作用就是用来创建对象的

​ 1、构造器的调用只能通过new关键词去调用 。

​ 2、当给一个类中的成员变量的；类型声明为基本数据类型之后，导致基本数据类型存在默认值。

实例代码：

/*
一个简单构造
**/
package studentList;

public class Student {
static int count=1;
int id;
String name;
int sex;
String classNo;
public Student() {

}
public Student(String name,int sex) {
this(name,sex,count++,"0708");
}
public Student(String name,int sex,int id,String classNo) {
this.classNo=classNo;
this.id=id;
this.sex=sex;
this.name=name;
}
public void info() {
System.out.println("我叫"+name+",学号是"+id+",性别是"+(sex==0?"男":"女")+",是"+classNo+"班的学生。");
}
}

注意：引用类型是指向一个地址，如果经过方法以后，改变了地址指向的值，则对象的属性会发生变化。

继承

继承的优势：

在一定程度上提高了代码的复用性

继承编写：

子类 extends 父类 子类拥有父类中的所有的成员变量（属性）以及方法（功能）。

什么是继承？：

将多个类中的共性再一次抽取，可以抽取为一个父类。父类的作用就是用来将一些重复的内容不再多次编写(提高代码复用性) 。

tips：

java中只支持单继承，一个子类有且只能有一个父类，但是复用性的提高是有限的 。

多继承好还是单继承好？

多继承 ：极大提高代码复用性 但是代码调用的复杂度也提升了。

单继承：代码调用的复杂度比较低，但是复用性比较有限。

this（）

*this 是自身的一个对象，代表对象本身

this的用法

1、普通直接引用。

2、形参与成员变量重名，可以用this来区分。

3、引用构造函数

super（）

*super 可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

super的用法

1、普通直接引用。

2、子类中的成员变量或方法与父类中的成员变量或方法同名

3、引用构造函数

tips：

this（）与super（）不能同时使用，且使用时，必须放在第一行。

内存分析

实例代码：

父类：

package Extend;

public class Person {
int age;
int sex;
String name;
public Person() {

}
public Person(String name) {
this.name=name;
}

public void eat() {
System.out.println(this.name+"父类:会吃饭");
};
}

子类：

package Extend;

public class Student extends Person {
static int count=1;
int id;
public Student() {

}
public Student(String name,int sex,int age) {
this(name,sex,count++,age);
}
public Student(String name,int sex,int id,int age) {
this.age=age;
this.id=id;
this.sex=sex;
this.name=name;
}
public void info() {
System.out.println("Student:我的名字叫"+name+",今年"+age+"岁，性别"+(sex==0?"男":"女")+",学号是："+id);
eat();//子类吃饭（方法重写）
super.eat();//父类吃饭用super调用
}
public void eat() {
System.out.println(this.name+"子类：会吃饭");
}
}

方法重写

*在子类中定义了和父类中同名的方法 我们将该方法称之为重写方法(覆盖)

为什么需要重写？

​ 父类的功能不能满足子类的需求。子类在父类的基础上进行了扩展。

如何确定一个方法是重写方法？

​ 在子类的方法上加入@Overried 注解 如果不报错 证明是重写

重写的前提：

​ 1、一定要发生继承关系。并且子类的方法名和父类的方法名同名

​ 2、参数列表要一样

​ 3、返回类型要一样

封装

修饰变量

	本类	同包下子类	同包下无关类	异包下子类	异包无关类
public	√	√	√	√	√
protected	√	√	√	√	×
默认	√	√	√	×	×
pravite	√	×	×	×	×

修饰方法

修饰符的作用：

​ 1、是用来屏蔽一些底层的实现逻辑，降低调用者(程序员)的复杂度。

​ 2、确保当前类更加安全。

修饰符可以修饰：

​ 1、类

​ 2、属性(成员变量) ：

修饰符的好处：

1、避免随意修改获取属性，造成数据不安全

2、如果用private修饰的话 一定要保证对外提供get（）、set（）方法让外部可见

方法。

3、屏蔽底层调用细节，降低调用者(程序员)的复杂度 使得代码更加健壮

实例代码

用面向对象的思想判断水仙花数：

package Flower;

public class Flower {
private int num;

public Flower() {
}
public Flower(int num) {
this.num=num;
}
public boolean isFlower() {//判断是否是水仙花数
if(this.num==sumFlower()) {
return true;
}
else {
return false;
}

}
public int sumFlower() {//计算水仙花的位数，与提取各个位之和
int a=0;//输入的数
int b=0;//保留各位
int sum=0;//计算各位N次幂之合
a=this.num;
while(a/10!=0) {
b=a%10;
a=a/10;
sum=sum+Xnum(b);
if(a/10==0) {
b=a%10;
sum=sum+Xnum(b);
}
}
return sum;
}
public int Xnum(int b) {//计算有N位，并且判定计算N次幂
int a=this.num;
int count=0;
int sum=1;
while(a/10!=0) {
a=a/10;
count++;
if(a/10==0) {
count++;
}
}
for(int i=1;i<=count;i++) {
sum=sum*b;
}
return sum;
}
public int getFlower() {
return this.num;
}
public void setFlower(int num) {
this.num=num;
}
}

将判断水仙花数封装：

package Flowerutil;
/**
* 	工具类：
* 		封装了判断数是否是水仙花数的方法，返回值为boolean值
*
*
* */
public class Flowerutil {
public static boolean isFlower(int num) {//判断是否是水仙花数
if(num==sumFlower(num)) {
return true;
}
else {
return false;
}

}
private static int sumFlower(int num) {//计算水仙花的位数，与提取各个位之和
int a=0;//输入的数
int b=0;//保留各位
int sum=0;//计算各位N次幂之合
a=num;
while(a/10!=0) {
b=a%10;
a=a/10;
sum=sum+Xnum(num,b);
if(a/10==0) {
b=a%10;
sum=sum+Xnum(num,b);
}
}
return sum;
}
private static int Xnum(int num,int b) {//计算有N位，并且判定计算N次幂
int a=num;
int count=0;
int sum=1;
while(a/10!=0) {
a=a/10;
count++;
if(a/10==0) {
count++;
}
}
for(int i=1;i<=count;i++) {
sum=sum*b;
}
return sum;
}
}