Java语言入门(七)——面向对象(四)
发布日期:2022-02-28 07:22:49 浏览次数:12 分类:技术文章

本文共 6266 字,大约阅读时间需要 20 分钟。

Java语言入门

instanceof关键字

class A {

 }class B {
 }class Test-7.1{
  public static void main(String[] args)
 {
 A a=new A();
//A a=new B();编译不通过
 B b=new B();
 System.out.println(b instanceof B);//true
 //System.out.println(b instanceof A);编译不通过
  }}
class A{

   }class B extends A{
   }class Test-7.2{
 public static void main(String[] args)
{
A a=new A();
 B b=new B();
  System.out.println(b instanceof B);  //true
 System.out.println(b instanceof A);  //true
 System.out.println(a instanceof B);  //false
 }}
class A{

   }class B extends A{
   }class Test-7.3{
 public static void main(String[] args)
{
A a=new B();
 System.out.println(a instanceof B);//true
}}

多态

运行期间判断
1 方法的多态 :重载和改写
2 对象的多态性:对象的两种转型(静态的体现)
(动态绑定)前提是针对方法而言,条件:
a.一定要有继承,
b.一定要有方法的改写,
c.对象的转型(向上转型):父类的引用指向子类的对象

区分重载与重写

重载 重写
定义 方法名相同,参数类型或个数不同 方法名、参数类型和返回类型都相同
范围 在同一个类中发生 只发生在继承类中
class Person{

 public void say()  {    System.out.println("^^ i am a person ^^");}}class Student extends Person {
 public void say()  {    System.out.println("** i am a student **");}}class Worker extends Person{
 public void say()  {    System.out.println("$$ i am a worker $$");}}class Test-7.4{
 public static void main(String[] args)  {
   fun(new Person());
//^^i am a person^^
fun(new Student());
   //**i am a student**
Worker w = new Worker();  //$$i am a worker$$
fun(w);
System.out.println();  }  static void fun(Person p)
{    p.say();}}

在这里插入图片描述

class Person{

 public void say()   {
 System.out.println("^^ i am a person ^^"); }  }class Student extends Person {
 public void say()   {
 System.out.println("** i am a student **"); }  }class Worker extends Person{
 public void say()   {
System.out.println("$$ i am a worker $$");  }   }class Boss{
 String name;
Person p;//成员变量p
Boss(String name,Person p)//局部变量p
{
  this.name=name;  this.p=p;  }
 public void say()  {
 this.p.say(); }}class Test-7.5{
 public static void main(String[] args)  {
Student s= new Student();
 Worker w=new Worker();
 Boss b=new Boss("huang",s);
 b.say();
//**i am a student**
 Boss b1=new Boss("huang",w);
  b1.say();
  //$$i am a worker$$
}}

在这里插入图片描述

动态绑定

抽象类abstract

抽象类有不含方法体的方法,主要用于子类的继承。可用于设计模板。
1 抽象类不能直接实例化(不能生成对象),只能被继承,通过其子类实例化
2 抽象类中是有构造方法的,但构造方法不能直接调用,只能由子类去重写
3 抽象类不能被final修饰,可以有静态的成员。若加final后为最终类,没有子类的抽象类没有实际的意义

abstract class Person{

 String name;
static int x=10;
Person() {
 }
public abstract void say();
public void walk() {
  };  }abstract class Teacher extends Person {    };class Student extends Person {
  public void say()
{
System.out.println("** i am a student **");}  }class Test-7.6{
 public static void main(String[] args)   {
  //Person p=new Person();
Person p=new Student();
p.say();   }
  //**i am a student**}

接口interface

接口是一种特殊的抽象类,只能有抽象的方法或全局常量。
1 接口中的成员变量默认都是public、static、final类型(全局性常量),必须被显式初始化
2 接口中的方法默认都是public、abstract类型的
3 接口没有构造方法,不能直接实例化
4 一个接口不能实现另一个接口,但它可以继承多个其他接口

interface Person{

 public static final String name="huang";
public abstract void say();
void walk();} /*系统默认public abstract和public static final,可以不写*/class Student implements Person {
  public void say()
{
System.out.println("** i am a student **");}
 public void walk(){
   };
 // void walk(){
};错误}class Test-7.7{
  public static void main(String[] args)
{
 System.out.println(); }}
interface Person{

  public abstract void say();
void walk();} interface A
{
 void walk();  }class Student implements Person,A {
  public void say()
{
System.out.println("** i am a student **");}
 public void walk(){
   };}class Test-7.8{
  public static void main(String[] args)
{
 System.out.println(); }}

对比类与接口

interface A  {

 }interface C  {
 }interface B extends A,C  {
  }//一个接口可以实现多个接口的继承(区别于类的特殊性)class B extends A,C  {
  }//错误class Test-7.9{
  public static void main(String[] args)
{
  System.out.println(); }}
interface A  {

 }class C  {
 }class B extends C inplements A  {
  }//先继承后实现class Test-7.10{
 public static void main(String[] args)   {
  System.out.println();  }}//通过接口可以实现多“继承”,一个类只能有一个直接父类,但可以实现多个接口

工厂类

interface USB   //工厂类的引入{

 public void start();//系统自动默认为public abstract void
public void end();}class Upan implements USB{
  public void start()
{
 System.out.println("Upan working");  }
public void end()
 {
 System.out.println("Upan stop"); }}class Mouse implements USB{
  public void start()
 {
 System.out.println("Mouse working");  }
 public void end()
 {
 System.out.println("Mouse stop");  }}class Test-7.11{
 public static void main(String[] args)   {
  USB u=new Upan();
u.start();
u.end();
USB m=new Mouse();
m.start();
m.end();
   System.out.println();   }}//后台改变,前台必须改变,设计不好
interface USB{

 public void start();//系统自动默认为public abstract void
public void end();}class Upan implements USB{
  public void start()
{
 System.out.println("Upan working");  }
public void end()
 {
 System.out.println("Upan stop"); }}class Mouse implements USB{
  public void start()
 {
 System.out.println("Mouse working");  }
 public void end()
 {
 System.out.println("Mouse stop");  }}class Factory  //工厂类{
 public static USB getIns(String className)   {
  if ("Upan".equals(className)) //常量.equals(变量)
 return new Upan();
else if("Mouse".equals(className))
  return new Mouse();
else  return null;   }}class Test-7.12{
 public static void main(String[] args)
{
 USB u=Factory.getIns("Mouse");
if(u!=null)  {
 u.start();   u.end();  }
System.out.println();
 }}
interface USB{

 public void start();//系统自动默认为public abstract void
public void end();}class Upan implements USB{
  public void start()
{
 System.out.println("Upan working");  }
public void end()
 {
 System.out.println("Upan stop"); }}class Mouse implements USB{
  public void start()
 {
 System.out.println("Mouse working");  }
 public void end()
 {
 System.out.println("Mouse stop");  }}class Computer{
  public static void Plugin(USB u)
{
  u.start();
u.end();
 }}class Test-7.13{
  public static void main(String[] args)
 {
  Computer.plugin(new Mouse());
  System.out.println();
  }}

对比抽象类与接口

1 都可以被继承
2 都不能被实例化
3 都可以包含方法声明
4 派生类必须实现未实现的方法

改写toString方法

class Text extends Object{

  public String toString()//改写了方法,打印对象时,就直接打印方法里的内容
 {
  return "i am Text";  }
 public static void main(String[] args)
 {
  System.out.println(new Text());   }}//不改写时,打印的是地址,改写后则为"i am Test"

转载地址:https://blog.csdn.net/weixin_45854582/article/details/106149649 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!

上一篇:解决No Access-Control-Allow-Origin header is present on the requested跨域问题
下一篇:Java语言入门(八)——异常处理机制

发表评论

最新留言

留言是一种美德,欢迎回访!
[***.191.171.25]2022年10月01日 20时34分40秒

关于作者

    喝酒易醉,品茶养心,人生如梦,品茶悟道,何以解忧?唯有杜康!
-- 愿君每日到此一游!

最新文章