黑马程序员-java方法

最新推荐文章于 2022-11-29 13:49:05 发布

DRMIVET Stone

最新推荐文章于 2022-11-29 13:49:05 发布

阅读量659

点赞数

分类专栏： java基础

Wangqi

本文链接：https://blog.csdn.net/u012651389/article/details/37841887

版权

java基础专栏收录该内容

15 篇文章 0 订阅

订阅专栏

<1.方法的重载和方法的覆写操作的比较
   No 比较点 重载 覆写
   1 英文单词 OverLoad Override
   2 概念 方法的名称类型或个数不同 方法名称，参数的类型或个数完全形同
   3 注意点 访问的权限不能变小
   4 范围 在一个类中发生 在继承类中发生
<2.对象的多态性
   接口和抽象类的概念
   多态性的存在让程序更加灵活
   多态性是面型对象的最后一个特征
   .方法的重载和覆写实际上就属于多态的一中表现
   .真正的多态性中还包含了一种称为对象多态性的概念
            对象多态性指的是子类与父类的转换关系
      向上转型：父类 父类对象=子类实例 -->自动完成
      乡下转型：子类 子类对象=（子类）父类实例 -->强制完成
说明：
package dom;
class A{
 public void fun1(){
  System.out.println("1.A类-->public void fun1()");
 }
 public void fun2(){
  this.fun1();
 }
};
class B extends A{
 public void fun1(){
  System.out.println("2,B类-->public void fun1()");
 }
 public void fun3(){
  System.out.println("3,B类-->public void fun3");
 }
 
};
public class Text {
 public static void main(String[]args){
  B b=new B();
  b.fun2();
  A a=b; //和A a=new B();一样
  a.fun2();
 }
}
2,B类-->public void fun1()
2,B类-->public void fun1()
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ublic class Text {
 public static void main(String[]args){
  B b=new B();
  b.fun2();
  A a=b; //和A a=new B();一样
  a.fun2();
  a.fun3();//这样会出现错误，因为父类没有这样的方法
 }
}
2.向下转型
package dom;
class A{
 public void fun1(){
  System.out.println("1.A类-->public void fun1()");
 }
 public void fun2(){
  this.fun1();
 }
};
class B extends A{
 public void fun1(){
  System.out.println("2,A类-->public void fun1()");
 }
 public void fun3(){
  System.out.println("3,B类-->public void fun3()");
 }
 
};
public class Text {
 public static void main(String[]args){
  A a=new B();//发生向上转型关系，子类实例-->父类实例
  B b=(B)a;//发生向下转型关系，强制
  b.fun3();
  b.fun2();
 }
}
3,B类-->public void fun3()
2,B类-->public void fun1()
******************************
例子：
//父子关系出现混乱的例子 此异常是继NolPoinyException之后,第二个最容易出现的异常，表示转换的异常
//造成的根本原因是两个没有关系的类进行相互的对象转换
package dom;
class A{
 public void fun1(){
  System.out.println("1.A类-->public void fun1()");
 }
 public void fun2(){
  this.fun1();
 }
};
class B extends A{
 public void fun1(){
  System.out.println("2,A类-->public void fun1()");
 }
 public void fun3(){
  System.out.println("3,B类-->public void fun3()");
 }
 
};
public class Text {
 public static void main(String[]args){
  A a=new A();//这里就像我在大街上被要钱了
  B b=(B)a;
  b.fun3();
  b.fun2();
 }
}
//Exception in thread "main" java.lang.ClassCastException: dom.A cannot be cast to dom.B
//at dom.Text.main(Text.java:23)
<3.
package dom;
class A{
 private void fun1(){
  System.out.println("1.A类-->public void fun1()");
 }
 public void fun2(){
  this.fun1();
 }
};
class B extends A{
 public void fun1(){
  System.out.println("2,B类-->public void fun1()");
 }
 public void fun3(){
  System.out.println("3,B类-->public void fun3()");
 }
 
};
class C extends A{
 public void fun1(){
  System.out.println("2,C" +
    "类-->public void fun1()");
 }
 public void fun4(){
  System.out.println("4,C类-->public void fun4()");
 }
 
};
public class Text {
 public static void main(String[]args){
  fun(new B());
  fun(new C());
 }
 public static void fun(B b){
  b.fun2();
  b.fun3();
 }
 public static void fun(C c){
  c.fun2();
  c.fun4();
 }
}
1.A类-->public void fun1()//private void fun1(){ public void fun1(){方法的覆写关键
3,B类-->public void fun3()
1.A类-->public void fun1()
4,C类-->public void fun4()
.以上的方法是通过重载完成，那么使用以上的方法完成会存在以下的缺点:如果现在A类的子类有100000个
  那么此方法就要重载10000000次而且每次都要修改代码
public class Text {
 public static void main(String[]args){
  fun(new B());
 }
 public static void fun(A a){
  a.fun2();
  B b=(B)a;
  b.fun3();
 }
}
 以上的代码仍然会出现转换异常，那么现在希望如果传入的对象时父类的人以实例调用fun方法取得对应程序
*在java 中提供了instanceof关键字完成这样的功能
格式
对象 instanceof 类-->返回boolean类型的数据 值是true false
public class Text {
 public static void main(String[]args){
 A a=new A();
 System.out.println( a instanceof A);
 System.out.println( a instanceof B);
 }
}
true
false
*******************************
public class Text {
 public static void main(String[]args){
 A a=new B();
 System.out.println( a instanceof A);
 System.out.println( a instanceof B);
 System.out.println( a instanceof C);
 }
}//发生了想下转型
true
true
false
<4.那么
public class Text {
 public static void main(String[]args){
  fun(new B());
  fun(new C());
 }
 public static void fun(A a){
  a.fun2();
  if(a instanceof B ){
   B b=(B) a;
   b.fun3();
  }
  if(a instanceof C){
   C c=(C) a;
   c.fun4();
  }
 }
}
2,B类-->public void fun1()
3,B类-->public void fun3()
2,C类-->public void fun1()
4,C类-->public void fun4()

.为了保证对象的正确转型的正确性，在操作之前最好加上instanceof()关键字进行判断
在java开发中父类的设计很重要
<5抽象类
包含一个抽象方法的类
抽象类不能直接实例化对象，但是可以声明如果
abstract class A{
  public abstract void fun();
 }
class B extends A{
  public void fun(){
    System.out.println("Hello word!!!");
   }
 }
public class Text {
   public static void main(String[]args){
     B b=new B();
     b.fun();
    }
 }
Hello word!!!
3.后象类能否使用final呢？
final abstract class A{//出现错误
  public abstract void fun();
 }
Text.java:1: 错误:非法修饰符abstruct和final
final abstract clas
               ^
Text.java:4: 错误:无法从A中继承
class B extends A{
4.抽象类能否有构造方法
 抽象类中允许有抽象方法，但是该方法不能直接调用，
 要通过子类调用。
abstract class A{
 public A(){
   System.out.println("父类的构造方法");
  }
  public abstract void fun();
 }
class B extends A{
 public B(){
   System.out.println("子类的构造方法");
  }
  public void fun(){
    System.out.println("Hello word!!!");
   }
 }
public class Text {
   public static void main(String[]args){
     B b=new B();
     b.fun();
    }
 }
父类的构造方法
子类的构造方法
Hello word!!!
**********
package dem;
abstract class A{
 private String name;
 public A(String name){
  this.name=name;
 }
 public String getName(){
  return this.name;
 }
 public abstract void fun();
}
class B extends A{
 public B(String name){
  super(name);
 }
 public void fun(){
  System.out.println("你好"+this.getName());
 }
}
public class Text {
 public static void main(String[]args){
  B b=new B("子类");
  b.fun();
 }
}
你好子类
<2.
关于抽象类的应用
从对象的多态性的概念上来看，子类为父类的实例化是一个比较容易的操作
因为可以在自动的向上转型关系，那么调用的方法永远是被子类覆写过的方法
 那么，此时就可以利用此概念通过对象的多态性为抽象类实例化
例如：
人分为两种 分为工人和学生
 假设工人和学生都有姓名和年龄属性但是工人有工龄，学生有成绩
 工人和学生都可以说话但是内容不一样
package dem;
abstract class A{
 private int age ;
 private String name;
 public A(String name,int age){
  this.age=age;
  this.name=name;
 }
 public abstract String getContent();
 public void say(){
  System.out.println(this.getContent());
 }
 public String getName(){
  return this.name;
 }
 public int getAge(){
  return this.age;
 }
}
class B extends A{
 String school;
 public String getSchool(){
  return this.school;
 }
 public B(String name,int age,String school){
  super(name,age);
  this.school=school;
 }
 public String getContent(){
  return "Im student";
 }
}
class C extends A{
 String gongling;
 public String getSchool(){
  return this.gongling;
 }
 public C(String name,int age,String gongling){
  super(name,age);
  this.gongling=gongling;
 }
 public String getContent(){
  return "Im worker";
 }
}
public class Text {
 public static void main(String[]args){
  A a=new B("王琪",20,"辽工大");
  A aa=new C("丫丫",20,"工龄50");
  a.say();
  aa.say();
 }
}
Im student
Im worker
<5.违纪卡
            违纪卡
姓名 班级
日期 事由
抽象类的最大用途在于模板设计
进而进入接口
package dom;
interface A{
 public void fun();
}
class B implements A{
 public void fun(){
  System.out.println("hello");
 }
}
public class text {
 public static void main(String[]args){
  A a=new B();//为接口实例化
  a.fun();
 }
}
hello
  接口是作为一个标准存在
  ***********USB****************
package dom;
interface USB{
 public void start();//开始操作
 public void stop();
}
class computer{
 public static void plugin(USB usb){
  usb.start();
  usb.stop();
 }
}
class Flash implements USB{
 public void start(){
  System.out.println("u盘开始工作");
 }
 public void stop(){
  System.out.println("u盘停止工作");
 }
}
class printer implements USB{
 public void start(){
  System.out.println("打印机开始工作");
 }
 public void stop(){
  System.out.println("打印机停止工作");
 }
}
public class text {
 public static void main(String[]args){
  computer.plugin(new Flash());
  computer.plugin(new printer());
 }
}
u盘开始工作
u盘停止工作
打印机开始工作
打印机停止工作
      
<6.接口（重点）
接口是一个特殊的类，在java中接口是由抽象方法和全局常量组成
在java中interface定义一个接口
  在接口中定义了两个抽象方法，一个全局常量
  那么接口与抽象类一样，需要有子类，那么此时子类
  不再称位继承类，而是实现接口通过implements实现
package dom;
interface first{
 public static final String INFO="CHINA";//public static final可省
 public abstract void print();//public abstract可省
 public abstract void fun();//public abstract可省
}
class second implements first{//子类实现接口
 public void print(){//实现抽象方法
  System.out.println("hello java");
 }
 public void fun() {
  System.out.println(INFO);
 }
}
public class Text2 {
 public static void main(String[]args){
  second b=new second();
  b.print();
  b.fun();
 }
}
hello java
CHINA
  一个类虽然只能继承一个父类，但是一个类可以同时实现多个接口，使用接口完成多继承
package dom;
interface first{
 public static final String INFO="CHINA";//public static final可省
 public abstract void print();//public abstract可省
 public abstract void fun();//public abstract可省
}
interface second {
 String mimi="琪琪";
 void talk();
}
class last implements first,second{//子类实现接口
 public void print(){//实现抽象方法
  System.out.println("hello java");
 }
 public void fun() {
  System.out.println(INFO);
 }
 public void talk(){
  System.out.println(INFO+mimi);
 }
}
public class Text2 {
 public static void main(String[]args){
  last b=new last();
  b.print();
  b.fun();
  b.talk();
 }
}
hello java
CHINA
CHINA琪琪
***************************
那么如果这样
package dom;
interface A{
 public void printA();
}
interface B{
 public void printB();
}
interface C extends A,B{
 public void printC();
}
abstract class D implements C{
 public abstract void printD();
public void printC(){
  System.out.println("Im C");
 }
}
class X extends D{
 public void printB() {
  System.out.println("Im B");
 }
 public void printA() {
  System.out.println("Im A");
 }
 public void printD() {
  System.out.println("Im D");
 }
 
}
public class Text2 {
 public static void main(String[]args){
  X x=new X();
  x.printA();
  x.printB();
  x.printC();
  x.printD();
 }
}
Im A
Im B
Im C
Im D
//一个抽象类可以实现多个接口，但是一个接口不可继承一个抽象类，但是一个接口可以继承多个接口
  <6.适配器设计
  开窗设计
  正常情况下接口的子类要实现全部的抽象方法
  现在想选根据自己的喜好择性的覆写
package dom;
interface Window{
 public void open();//打开窗口
 public void close();//关闭窗口
 public void inco();//最大化
 public void uninco();//最小化
}
abstract class windowAdpater implements Window{
 public void open(){}
 public void close(){}
 public void inco(){}
 public void uninco(){}
}
class myWindow extends windowAdpater{
 public void open(){
  System.out.println("打开窗口");
 }
}
public class Text3 {
 public static void main(String[]args){
  Window win=new myWindow();
  win.open();
 }
}
打开窗口
<6.//适配器设计（工厂设计模式）
   package dom;
interface Fruit{
 public void eat();
}
class Apple implements Fruit{
 public void eat(){
  System.out.println("吃苹果..");
 }
}
class Orange implements Fruit{//工厂类
 public void eat(){
  System.out.println("吃橘子..");
 }
}
class myFruit {
 public static Fruit getFruit(String classname){
  Fruit f=null;
  if("Apple".equals(classname)){
   f=new Apple();
  }
  if("Orange".equals(classname)){
   f=new Orange();
  }
  return f;
 }
}
public class Text {
 public static void main(String[]args){
  Fruit f=myFruit.getFruit(args[0]);
  if(f!=null){
   f.eat();
  }
 }
}
D:\java>
D:\java>
吃苹果..
D:\java>
吃橘子..
D:\java>
Exceptio
D:\java>
所有的实例化对象通过工厂类取得
那么客户调用不同的名称完成不同的操作