这篇文章主要介绍了java的三大特性怎么使用的相关知识,内容详细易懂,操作简单快捷,具有一定借鉴价值,相信大家阅读完这篇java的三大特性怎么使用文章都会有所收获,下面我们一起来看看吧。
创新互联公司专注于做网站、网站制作、网页设计、网站制作、网站开发。公司秉持“客户至上,用心服务”的宗旨,从客户的利益和观点出发,让客户在网络营销中找到自己的驻足之地。尊重和关怀每一位客户,用严谨的态度对待客户,用专业的服务创造价值,成为客户值得信赖的朋友,为客户解除后顾之忧。
java的三大特性是:1、封装,就是将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。2、继承,就是子类拥有父类的所有属性和方法,从而实现了实现代码的复用。3、多态,就是父类引用指向子类对象,从而产生多种形态。
面向对象三大特性:封装、继承、多态。
封装:
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。
继承:
子类拥有父类的所有属性和方法(除了private修饰的属性不能拥有),从而实现了实现代码的复用;
多态:
使用父类引用接受,不同的子类的对象实例,父类引用调用相同的方法,根据子类不同的实例,产生不同的结果
1、封装
概念:尽可能隐藏对象的内部实现细节,控制对象的修改及访问的权限。
访问修饰符:private (可将属性修饰为私有,仅本类可见)
以访问方法的形式,进而完成赋值与取值操作。
问题:依旧没有解决到非法数据录入!
提供公共访问方法,以保证数据的正常录入。
命名规范:
赋值:setXXX() //使用方法参数实现赋值
取值:getXXX() //使用方法返回值实现取值
public static void main(String[] args) {
int a;
Num num = new Num();
// 传入值100
num.setNum(100);
System.out.println(num.getNum());
}
private int a;
// 在调用get方法时,返回本类a的值
public int getNum() {
return a;
}
// 接受传入的值100,并赋值给本类的a
public void setNum(int num) {
this.a = num;
}
在公共的访问方法内部,添加逻辑判断,进而过滤掉非法数据,以保证数据安全。
get/set方法是外界访问对象私有属性的唯一通道,方法内部可对数据进行检测和过滤。
2、继承
程序中的继承,是类与类之间特征和行为的一种赠与或获得。
两个类之间的继承关系,必须满足“is a”的关系。
现实生活中,很多类别之间都存在着继承关系,都满足“is a”的关系。
狗是一种动物、狗是一种生物、狗是一种物质。
多个类别都可作为“狗”的父类,需要从中选择出最适合的父类。
功能越精细,重合点越多,越接近直接父类。
功能越粗略,重合点越少,越接近Object类。(万物皆对象的概念)
语法:class 子类 extends 父类{ } //定义子类时,显示继承父类
public class 子类名 extends 父类名{
//代码块
}
应用:产生继承关系之后,子类可以使用父类中的属性和方法,也可定义子类独有的属性和方法。
好处:既提高代码的复用性,又提高代码的可扩展性。
Java为单继承,一个类只能有一个直接父类,但可以多级继承,属性和方法逐级叠加。
构造方法:类中的构造方法,只负责创建本类对象,不可继承。
private修饰的属性和方法:访问修饰符的一种,仅本类可见。
父子类不在同一个package中时,default修饰的属性和方法:访问修饰符的一种,仅同包可见。
3、方法重写
方法重写原则:
方法名称、参数列表与父类相同。
返回值类型必须与父类相同或其子类
访问修饰符可与父类相同或是比父类更宽泛。
方法重写的执行:
子类重写父类方法后,调用时优先执行子类重写后的方法。
方法重写的特性:
子类重写父类方法时子类方法会覆盖父类方法。
子类重写父类方法,访问级别不能严于父类方法。
子类重写方法名和类型与父类一样。
父类的构造方法无法重写,只能被覆盖。
示例:
//父类
public class Animal {
// 父类中吃的方法会输出“玩玩玩”
public void play() {
System.out.println("玩玩玩");
}
// 父类中睡的方法会输出“睡睡睡”
public void sleep() {
System.out.println("睡睡睡");
}
}
/**
* 狗类继承 父类
*/
public class Dog extends Animal {
// 进行方法重写,将方法重写输出为“狗玩飞碟”
public void play() {
System.out.println("狗玩飞碟");
}
}
public class Test {
public static void main(String[] args) {
// 实例化宠物对象
Dog d = new Dog();
d.play();
d.sleep();
}
}
运行输出:
相同点:方法名相同
不同点:
重载:参数列表不同,返回值与访问修饰符无关
重写:参数列表相同,返回值相同或其子类,访问修饰符不能比父类更严
4、super关键字
super关键字可在子类中访问父类的方法。
使用”super.”的形式访问父类的方法,进而完成在子类中的复用;
再叠加额外的功能代码,组成新的功能。
super():表示调用父类无参构造方法。如果没有显示书写,隐式存在于子类构造方法的首行。
super():表示调用父类无参构造方法。
super(实参):表示调用父类有参构造方法。
参构造被执行
this或super使用在构造方法中时,都要求在首行。
当子类构造中使用了this()或this(实参),即不可再同时书写super()或super(实参),会由this()指向构造方法完成super()调用。
class A{
public A(){
System.out.println(( "A-无参构造"));
}
public A(int value) {
System.out.println(("A-有参构造"));
}
}
class B extends A{
public B(){
super();
System.out.println( "B-无参构造");
}
public B(int value) {
// super();这两货不能跟同时存在
this();
System.out.println(("B-有参构造"));
}
}
5、多态
概念:父类引用指向子类对象,从而产生多种形态。
二者具有直接或间接的继承关系时,父类引用可指向子类对象,即形成多态。
父类引用仅可调用父类所声明的属性和方法,不可调用子类独有的属性和方法。
方法重载可以解决接收不同对象参数的问题,但其缺点也比较明显。
首先,随着子类的增加,Master类需要继续提供大量的方法重载,多次修改并重新编译源文件。
其次,每一个feed方法与某一种具体类型形成了密不可分的关系,耦合太高。
场景一:使用父类作为方法形参实现多态,使方法参数的类型更为宽泛。
public class Animal {
// 父类中吃的方法会输出“玩玩玩”
public void play() {
System.out.println("玩玩玩");
}
// 父类中睡的方法会输出“睡睡睡”
public void sleep() {
System.out.println("睡睡睡");
}
}
/**
* 狗类继承 父类
*
*
*
*/
public class Dog extends Animal {
// 狗类特有的方法“狗吃狗粮”
public void eat() {
System.out.println("狗吃狗粮");
}
}
public class Test {
public static void main(String[] args) {
// 实例化宠物对象
Animal d = new Dog();
d.play();
d.sleep();
// The method eat() is undefined for the type Animal
// 对于类型动物,eat()方法未定义
// 当我们去调用子类对象的特有方法时,就会爆出上面的错误提示
// 如果想要实现子类特有方法,就必须要强转
// d.eat();
((Dog) d).eat();
}
}
运行输出:
场景二:使用父类作为方法返回值实现多态,使方法可以返回不同子类对象。
示例:
//动物类 父类
public class Animal {
public void food() {
System.out.println("...");
}
}
//用extends关键字,继承父类属性
public class Dog extends Animal {
public void food() {
System.out.println("狗吃狗粮");
}
public void runing() {
System.out.println("一直跑跑跳跳");
}
}
//用extends关键字,继承父类属性
public class Fish extends Animal {
public void food() {
System.out.println("大鱼吃小鱼,小鱼吃虾米");
}
public void swimming() {
System.out.println("小鱼儿,一直游");
}
}
public class Master {
// 传入你的动物,并去给它喂食
public void food(Animal animal) {
System.out.println("喂食");
animal.food();
}
}
import java.util.Scanner;
public class Shopping {
// 你没有动物,所以animal为空
Animal animal = null;
// 判断你要购买的宠物,并返回宠物类(狗、鱼)
public Animal shopping(int a) {
if (a == 1) {
animal = new Dog();
} else if (a == 2) {
animal = new Fish();
}
// this.animal=animal;
return animal;
}
public void showMenu() {
Scanner input = new Scanner(System.in);
System.out.println("欢迎来到一只宠物宠物店");
System.out.println("请选择喜欢的宠物:");
System.out.println("1.狗 2.鱼 ");
int a = input.nextInt();
Animal animal = shopping(a);
Master mm = new Master();
mm.food(animal);
// 用instanceof判断你买的是狗还是鱼。
// 狗就执行狗的属性和方法,鱼就执行鱼的属性和方法
if (animal instanceof Dog) {
Dog d = (Dog) animal;
d.runing();
} else if (animal instanceof Fish) {
Fish f = (Fish) animal;
f.swimming();
}
}
}
//测试类
public class text {
public static void main(String[] args) {
Shopping shop = new Shopping();
shop.showMenu();
}
}
运行结果:
动态绑定
:即为重写/覆盖,方法的重写
动态绑定也叫后期绑定,在运行时,虚拟机根据具体对象实例的类型进行绑定,或者说是只有对象在虚拟机中运行创建了之后,才能确定方法属于哪一个对象实例的
根据实际对象是什么,就去找相应对象方法去执行。
动态绑定是在运行时才会执行(例如重写的方法)。
静态绑定
:即为重载,方法的重载
一个方法的参数在编译阶段常被静态地绑定,它是根据参数列表的不同来区分不同的函数,通过编辑之后会变成两个不同的函数
根据类型找相应的属性或者静态变量。
静态绑定是在编译时执行(如成员变量,静态方法)。
关于“java的三大特性怎么使用”这篇文章的内容就介绍到这里,感谢各位的阅读!相信大家对“java的三大特性怎么使用”知识都有一定的了解,大家如果还想学习更多知识,欢迎关注创新互联行业资讯频道。