面向对象
构造器
构造器的用法
在类中用来创建对象那个的方法称之为构造器 构造函数 构造方法
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;
}
}