目录

十五、Object类

1.toString

2.equals

十六、对象转型(casting)

十七、动态绑定(多态)

十八、抽象类(abstract)

十九、final关键字

二十、接口

十五、Object类

Object类是所有java类的根基类

如果在类的声明中未使用extends关键字致命其基类,则默认基类为Object类,也就是说

public class Person {…}等价于public classPerson extends Object {…}

1.toString

Object类中定义有public String tuString()方法,其返回值是String类型,描述当前对象的有关信息

在进行String与其他类型数据的链接操作时(如:System.out.print(“info”+person)),将自动调用该对象类的toString()方法

可以根据需要在用户自定义类型中重写toString()方法

//测试类
public class Test {
public static void main(String[] args) {
Dog d = new Dog();
System.out.println("d: "+d);
//等价于
System.out.println("d: "+d.toString());
}
}
class Dog {
}

输出结果:

d: jian_study.Dog@2a139a55
d: jian_study.Dog@2a139a55

如果对于Object中某些方法不满意可以自己在自己类中进行重写,例如:

public class Test {
public static void main(String[] args) {
Dog d = new Dog();
System.out.println("d: "+d);
//等价于
System.out.println("d: "+d.toString());
}
}
class Dog {
public String toString(){
return "HelloWorld!";
}
}
//输出结果
d: HelloWorld!
d: HelloWorld!

2.equals

public boolean equals(Object obj)方法

提供定义对象是否相等的逻辑,使用格式:

x.equals(y)当x和y是同一个对象的应用时返回true,斗则返回false

jdk提供的一些类,如String,Date等,重写了OBject的equals方法,调用这些类的equals方法,x.equals(y),当x和y所引用的对象是同一类对象且属性能容相等时(并不一定是相同对象),返回true,否则返回false

可以根据需要在用户自定义类型中重写equals方法

public class Test {
public static void main(String[] args) {
Dog d1 = new Dog();
Dog d2 = new Dog(); System.out.println(d1 == d2);
System.out.println(d1.equals(d2)); }
}
class Dog {
}

输出结果:

false
false

可以查看javaAPI文档来查看输出为false的原因,这个时候就可以进行方法重写

public class Test {
public static void main(String[] args) {
Dog d1 = new Dog();
Dog d2 = new Dog(); System.out.println(d1 == d2);
System.out.println(d1.equals(d2)); }
}
class Dog {
public boolean equals(Object obj) {
return true;
}
}

再来看返回结果

false
true

这里只是说明系统方法也是可以重写的,并且进行了一个简单的举例

十六、对象转型(casting)

一个基类的引用类型变量可以“指向”其子类的对象

一个基类的引用不可以访问其子类对象新增的成员(属性和方法)。

可以使用引用变量instanceof类名来判断该引用型变量所指向的对象是否属于该类或该类的子类

子类的对象可以当作基类的对象来使用称作向上转型(upcasting),反之称为向下转型(downcasting)

先看一个例子:

//新建一个基类
public class Animal {
public String name;
Animal(String name) {
this.name = name;
}
}
//新建一个子类Cat继承Animal基类
public class Cat extends Animal {
public String eyesColor;
Cat(String n, String c) {
super(n);
eyesColor = c;
}
}
//新建一个子类Dog继承基类Animal
public class Dog extends Animal{
public String funColor;
Dog(String n,String c) {
super(n);
funColor = c;
}
}
//测试类1
public class Test {
public static void main(String args[]) {
Animal a = new Animal("name");
Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname", "black");
//a的引用是否指向Animal
System.out.println(a instanceof Animal);//true
//c的引用是否指向Animal
System.out.println(c instanceof Animal);//true
//d的引用是否指向Animal
System.out.println(d instanceof Animal);//true
//a的引用是否指向Cat
System.out.println(a instanceof Cat);//false
// 父类引用指向子类对象,所以父类无法调用子类的furname属性,所以会报错
a = new Dog("bigyellow","yellow");
System.out.println(a.name);//bigyellow
//System.out.println(a.furname);//error
//a的引用知否指向Animal
System.out.println(a instanceof Animal);////true
//a的引用是否指向Dog,因为instanceof探测的是你实际当中是个什么类型,所以这里会返回true
System.out.println(a instanceof Dog);//true
//强制类型转换,所以下面会返回true
Dog d1 = (Dog)a;
System.out.println(d1.funColor);//yellow
}
}
//测试类2
public class Test {
public static void main(String args[]) {
Test test = new Test();
Animal a = new Animal("name");
Cat c = new Cat("catname", "blue");
Dog d = new Dog("dogname", "black");
test.f(a);
test.f(c);
test.f(d);
}
//定义一个方法
public void f(Animal a) {
System.out.println("name: "+a.name);
if(a instanceof Cat) {
Cat cat = (Cat)a;
System.out.println(" "+cat.eyesColor+" eyes");
}else if(a instanceof Dog) {
Dog dog = (Dog)a;
System.out.println(" "+dog.funColor+" fur");
}
}
} /*输出结果
name: name
name: catname
blue eyes
name: dogname
black fur
*/

十七、动态绑定(多态)

动态绑定是指“在执行期间(而非编译其间)判断所引用对象的实际类型,根据其实际的类型调用其相应的方法”

看一个例子

//新建一个基类
public class Animal {
public String name;
Animal(String name) {
this.name = name;
}
public void enjoy() {
System.out.println("叫声....");
}
}
//新建一个子类Cat继承Animal基类
public class Cat extends Animal {
public String eyesColor;
Cat(String n, String c) {
super(n);
eyesColor = c;
}
public void enjoy() {
System.out.println("猫叫声...");
}
}
//新建一个子类Dog继承基类Animal
public class Dog extends Animal{
public String funColor;
Dog(String n,String c) {
super(n);
funColor = c;
}
public void enjoy() {
System.out.println("狗叫声...");
}
}
//Lady类
public class Lady {
private String name;
private Animal pet;
Lady(String name,Animal pet) {
this.name = name;
this.pet = pet;
}
public void myPetEnjoy() {
pet.enjoy();
}
}
//测试类
public class Test {
public static void main(String args[]) {
Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname", "black");
Lady l1 = new Lady("l1",c);
Lady l2 = new Lady("l2", d);
l1.myPetEnjoy();
l2.myPetEnjoy();
}
}

输出结果为:

猫叫声...
狗叫声...

上面的例子中,根据lady对象的成员变量pet所引用的不同的实际类型而调用相应的enjoy方法

Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname", "black");

Lady l1 = new Lady("l1",c);

上面三行代码的内存分配图如下:

enjoy方法有三个,分别是animal的,dog的和cat的,动态绑定就是调用的实际new的那个方法,指向的就是那个方法。也就是l1指向的实际方法应该是cat的那个enjoy方法。

当后期需要扩展的时候,只需要加一个扩展类,然后在test类中new一个扩展对象出来并使用对象.方法的方式引用即可,扩展性非常强

多态的存在有三个必要条件:

1)要有继承

2)要有重写

3)父类引用指向子类对象

十八、抽象类(abstract)

使用abstract关键字来修饰一个类的时候,这个类叫做抽象类;同样的,使用abstract来修饰一个方法时,这个方法叫做抽象方法。

含有抽象方法的类必需被声明为抽象类,抽象类必需被继承,抽象方法必需被重写。

抽象类不能被实例化

抽象方法只需声明,而不需要实现

//修改基类
abstract class Animal {
public String name;
Animal(String name) {
this.name = name;
}
/*
public void enjoy() {
System.out.println("叫声....");
}
*/
public abstract void enjoy();
}

由于在之前的那个例子中,基类的方法是没有被实现的,这个时候就可以使用abstract关键字将基类的方法和类变为抽象方法、抽象类,只是被继承,强制子类必需重写方法

十九、final关键字

final修饰的变量的值不能够被改变

final修饰的方法不能够被重写

final修饰的类不能够被继承

//示例代码
public class TestFinal {
public static void main(String[] args) {
T t = new T();
t.i = 9;
} }
class T {
final int i = 0;
}

如上的代码中会报错,因为在T类中已经定义了final int i的值,所以在new出来的新的t中是无法对i的值进行修改的,即便把t.i改为0也会报错。因为在执行过程中是将0重新赋值给了t.i

二十、接口

接口(interface)是抽象方法和常量值的定义的集合

本质上讲,接口是一种特殊的抽象类,这种抽象类中值包含常量和方法的定义,而没有变量和方法的实现

接口定义举例:

public interface Runner {
public static final int id = 1;
public void start();
public void run();
public void stop();
}

接口特性:

  • 接口可以多重实现
  • 接口中声明的属性默认为public static final的;也只能是public static final的
  • 接口只能定义抽象方法,而且这些方法默认为public的,也只能是public的
  • 接口可以继承其他的接口,并添加新的属性和抽象方法
  • 多个无关的类可以实现同一个接口
  • 一个类可以实现多个无关的接口
  • 与继承关系类似,接口与实现类之间存在多态性

定义java类的语法格式:

< modifier > class < name > [ extends < superclass > ] [ implements < interface > [ , <interface> ] * ] {
< declarations > *
}

看个例子:

//定义一个接口类Singer
interface Singer {
public void sing();
public void sleep();
} //再定义一个接口类
interface Painter {
public void paint();
public void eat();
} //定义students类实现singer接口
public class Students implements Singer {
private String name;
Students(String name) {
this.name = name;
}
public void study() {
System.out.println("studying...");
}
public String getName() {
return name;
}
public void sing() {
System.out.println("student is singing...");
}
public void sleep() {
System.out.println("student is sleeping..");
}
} //定义类实现singer和painter类
class Teacher implements Singer,Painter{
private String name;
public String getString() {
return name;
}
Teacher(String name) {
this.name = name;
}
public void teach() {
System.out.println("teaching");
}
public void sing(){
System.out.println("teacher is singing");
}
public void sleep() {
System.out.println("teacher is sleeping");
}
public void paint() {
System.out.println("teacher is painting");
}
public void eat() {
System.out.println("teacher is eating");
}
}
//调试输出的测试类
public class test {
public static void main(String args[]) {
Singer s1 = new Students("s1");
s1.sing();
s1.sleep();
Singer s2 = new Teacher("s2");
s2.sing();
s2.sleep();
Painter p1 = (Painter)s2;
p1.paint();
p1.eat();
}
}

输出结果:

student is singing...
student is sleeping..
teacher is singing
teacher is sleeping
teacher is painting
teacher is eating

五、java面向对象编程_3的更多相关文章

  1. JAVA学习(五):Java面向对象编程基础

    Java面向对象编程基础 面向对象(Object oriented programming,OOP)技术是一种强有力的软件开发方法,它採用数据抽象与信息隐藏技术,来使软件开发简单化,以达到代码重用的目 ...

  2. JAVA面向对象编程课程设计——网络版单机斗地主

    一.团队介绍 成员姓名 任务分配 成员课程设计博客链接 兰泽祥(组长) 数据库,斗地主规则的实现,人机自动出牌的算法,实体类的设计 JAVA面向对象编程课程设计--web版斗地主 吴修恩 JSP界面的 ...

  3. JAVA面向对象编程课程设计——web版斗地主

    一.团队课程设计博客链接 JAVA面向对象编程课程设计--网络版单机斗地主 二.个人负责模块或任务说明 实体类的设计 斗地主规则的实现 人机自动出牌的算法 实现数据库的DAO模式 三.自己的代码提交记 ...

  4. 20145213《Java程序设计》实验五Java网络编程及安全

    20145213<Java程序设计>实验五Java网络编程及安全 实验内容 1.掌握Socket程序的编写. 2.掌握密码技术的使用. 3.设计安全传输系统. 实验预期 1.客户端与服务器 ...

  5. 20145206《Java程序设计》实验五Java网络编程及安全

    20145206<Java程序设计>实验五 Java网络编程及安全 实验内容 1.掌握Socket程序的编写: 2.掌握密码技术的使用: 3.设计安全传输系统. 实验步骤 我和201451 ...

  6. 20145337实验五Java网络编程及安全

    20145337实验五Java网络编程及安全 实验内容 掌握Socket程序的编写 掌握密码技术的使用 设计安全传输系统 实验步骤 基于Java Socket实现安全传输 基于TCP实现客户端和服务器 ...

  7. JAVA课程实验报告 实验五 Java网络编程及安全

    北京电子科技学院(BESTI) 实     验    报     告 课程:Java程序设计  班级:1353  姓名:韩玉琪  学号:20135317 成绩:             指导教师:娄嘉 ...

  8. 20145225《Java程序设计》 实验五 Java网络编程及安全

    20145225<Java程序设计> 实验五 Java网络编程及安全 实验报告 一.实验内容 基于Java Socket实现安全传输. 基于TCP实现客户端和服务器,结对编程一人负责客户端 ...

  9. 20145208 实验五 Java网络编程

    20145208 实验五 Java网络编程 实验内容 1.用书上的TCP代码,实现服务器与客户端. 2.客户端与服务器连接 3.客户端中输入明文,利用DES算法加密,DES的秘钥用RSA公钥密码中服务 ...

随机推荐

  1. fs - 文件系统

    fs 模块提供了一些 API,用于以一种类似标准 POSIX 函数的方式与文件系统进行交互. 用法如下: const fs = require('fs'); 所有的文件系统操作都有异步和同步两种形式. ...

  2. 《Spring1之第十次站立会议》

    <第十次站立会议> 昨天:试着把用C#写的代码转换为java语言. 今天:已基本转换为java语言了,也能够实现视频聊天这个功能了. 遇到的问题:在进行视频通话时没有考虑到声音优化功能,实 ...

  3. Beta Scrum Day 5 — 听说

    听说

  4. DPDK skeleton basicfwd 源码阅读

    学习这个例子用于理解单纯的 dpdk 转发过程,L2 和 L3 的转发是基于此:在rte_eth_rx_burst()收包后进行解包,提取 mac.ip 等信息然后在转发到输出网卡. 如果要写出自己的 ...

  5. grunt入门讲解5:创建插件,安装Grunt以及常见问题

    创建插件 创建插件主要有以下几个步骤: (1)通过 npm install -g grunt-init 命令安装 grunt-init .(2)通过 git clone git://github.co ...

  6. IIS8.5 的环境下添加配置WCF服务!!!!!

    添加步骤: 1.打开iis8.5,先部署wcf服务. 2.首先添加MIME类型 扩展名:“.svc” MIME类型:“application/octet-stream” 3.添加 处理程序映射 请求路 ...

  7. Alpha阶段博客链接

    博客链接 团队项目启程篇章:http://www.cnblogs.com/liuliudashun/p/5968194.html 团队项目开发篇章1:http://www.cnblogs.com/li ...

  8. VR论文调研

    IEEE VR 2018 1.Avatars and Virtual Humans--人物和虚拟人物 2.Augmented Reality--增强现实 3.Body and Mind--人体和思想( ...

  9. linux安全配置学习

    参考摘自https://www.cnblogs.com/hiccup/p/4300963.html 1.关闭icmp请求 #vm虚拟机是130地址,通过echo 1 > /proc/sys/ne ...

  10. 微信小程序 功能函数 openid本地和网络请求

    本地-------------------------------------------------------------------------------------------------- ...