java中构造器、继承、封装的基本用法

面向对象

构造器

构造器的用法

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

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;
	}			
}



  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值