Java 基础面向对象高级

最新推荐文章于 2024-08-19 16:01:20 发布

曹文涛

最新推荐文章于 2024-08-19 16:01:20 发布

阅读量576

点赞数

文章标签： java string class fun interface

本文链接：https://blog.csdn.net/a62258110/article/details/6720951

版权

面向对象高级

继承的基本实现

在JAVA中使用extends关键字完成类的继承关系，格式：

class 父类{} //定义父类

class 子类 extends 父类{} //使用extends关键字实现继承

继承：子类继承父类，可以扩展已有类的功能。

继承的限制

在JAVA中只允许单继承，不能使用多重继承，即：一个子类只能继承一个父类。但是允许进行多层继承，即：一个子类可以有一个父类，一个父类还可以有一个父类

访问限制：在使用继承的时候也应注意的是：子类是不能直接访问父类中的私有成员的，但是子类可以调用父类中的非私有方法，但是不能直接调用父类中的私有成员。

子类对像的实例化过程

在继承操作中，对于子类对象的实例化也是有要求的：“子类对象在实例化之前必须首先调用父类中的构造方法之后再调用子类自己的构造方法。

方法覆写

在继承关系中也存在着方法覆写概念，所谓的方法覆写就是指子类定义了与父类中同名的方法，但是方法覆写时必须考虑到权限。即：被子类覆写的方法不能拥有比父类方法更加严格的方问权限。

super关键字可以从子类访问父类中的内容，如果要访问被覆写过的方法：super.方法()

属性覆盖

方法覆写有很多的要求，属性的覆盖，主要就是指在子类中声明了与父类同名的属性。

super关键字

super表示的是从子类调用父类中的指定操作，例如：调用属性、方法、构造等。因为在子类实例化的时候会默认调用父类中的无参构造，如果现在希望调用有参构造，则必须在子类中明确的声明。

this与supers本身都是可以调用构造方法，而且调用的时候必须放在构造方法的首行，所以这两个关键字肯定不能同时出现。

范例：继承的应用

要求：定义一具整型数组类，要求包含构造方法，增加数据及输出数据成员方法，并利用数组实现动态内存分配。在此基础上定义出子类：排序类反转类

final关键字

final在JAVA中表示的意思是最终的意思。也可以称为完结器。

可以使用final关键字声明类、属性、方法：

使用final声明的类不能有子类；

使用final声明的方法不能被子类所覆写；

使用final声明的变量即成为常量，常量不可以修改。

全局常量

使用static final关键字联合声明的变量称为全局常量

pubilc static final String INFO = “JAVA”;

抽象类的基本概念

抽象类：包含一个抽象方法的类就称为抽象类。

抽象方法：只声明而未实现的方法称为抽象方法，抽象方法必须使用abstract关键字声明。

抽象类的定义及使用规则

包含一个抽象方法的类必须是抽象类

抽象类和抽象方法都要使用abstract关键字声明

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

抽象类必须被子类继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法

抽象类的定义格式

abstract class 抽象类名称{

属性;

访问权限返回值类型方法名称(参数){ //普通方法

[return 返回值]

}

访问权限 abstract 返回值类型方法名称(参数);

}

抽象类必须有子类，子类必须覆写抽象类中的全部抽象方法

接口的基本概念

接口是JAVA中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。

接口用关键字interface声明

实现接口

与抽象类一样，接口要使用也必须通过子类，子类通过implen\ments关键字实现接口

格式：class 子类 implements 接口A，接口B,…..{}

接口使用中也须有子类，子类必须覆写全部抽象方法，一个子类可以同时实现多个接口。

一个子类可以同时继承抽象类和实现接口

操作实例

interface A{           // 定义接口A
       public String AUTHOR = "JAVA" ;      // 全局常量
       public void print() ;       // 抽象方法
       public String getInfo() ; // 抽象方法
}
abstract class B implements A{     // 定义抽象类B，实现接口A
       public abstract void say() ;    // 定义抽象方法
}
class X extends B{  // X类线继承B类
       public void say(){
              System.out.println("Hello World!!!") ;
       }
       public String getInfo(){
              return "HELLO" ;
       }
       public void print(){
              System.out.println("作者：" + AUTHOR) ;
       }
}
public class InterfaceDemo05{
       public static void main(String args[]){
              X x = new X() ;     // 实例化子类对象
              x.say() ;
              x.print() ;
       }
}

对象的多态性

多态性在面向对象中是一个重要的概念，主要分为两种类型：

向上转型：子类对象à父类对象

对于向上转型，程序会自动完成格式：父类父类对象 = 子类实例；

向下转型：父类对象à子类对象

对于向下转型，必须明确指明要转型的子类类型，格式：

子类子类对象 = （子类）父类实例；

实例：

class A{                               // 定义类A
       public void fun1(){              // 定义fun1()方法
              System.out.println("A --> public void fun1(){}") ;
       }
       public void fun2(){
              this.fun1() ;           // 调用fun1()方法
       }
}
class B extends A{
       public void fun1(){              // 此方法被子类覆写了
              System.out.println("B --> public void fun1(){}") ;
       }
       public void fun3(){
              System.out.println("B --> public void fun3(){}") ;
       }
}
public class PolDemo02{
       public static void main(String asrgs[]){
              A a = new B() ;                    // 向上转型关系
              B b = (B)a ;           // 发生了向下转型关系
              b.fun1() ;
              b.fun2() ;
              b.fun3() ;
       }
}

instanceof关键字

JAVA中可以使用instanceof关键字判断一个对象到底是哪个类的实例。

对类 instanceof 类 à 返回boolean类型

实例：

class A{                               // 定义类A
       public void fun1(){              // 定义fun1()方法
              System.out.println("A --> public void fun1(){}") ;
       }
       public void fun2(){
              this.fun1() ;           // 调用fun1()方法
       }
}
class B extends A{
       public void fun1(){              // 此方法被子类覆写了
              System.out.println("B --> public void fun1(){}") ;
       }
       public void fun3(){
              System.out.println("B --> public void fun3(){}") ;
       }
}
class C extends A{
       public void fun1(){              // 此方法被子类覆写了
              System.out.println("C --> public void fun1(){}") ;
       }
       public void fun5(){
              System.out.println("C --> public void fun5(){}") ;
       }
}
public class InstanceofDemo02{
       public static void main(String asrgs[]){
              fun(new B()) ;
              fun(new C()) ;
       }
       public static void fun(A a){
              a.fun1() ;
              if(a instanceof B){
                     B b = (B) a ;
                     b.fun3() ;
              }
              if(a instanceof C){
                     C c = (C) a ;
                     c.fun5() ;
              }
       }
}

一个类永远不要去继承一个已经实现好了的类。而只能继承抽象类或实现接口

抽象类与接口的应用

在JAVA中可以通过对象的多态性，为抽象类和接品实例化，这样再使用抽象类和接口的时候就可以调用本子类中所覆写过的方法了。

抽象类的应用——定义模板

实例：

abstract class Person{
       private String name ;            // 定义name属性
       private int age ;                    // 定义age属性
       public Person(String name,int age){
              this.name = name ;
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public int getAge(){
              return this.age ;
       }
       public void say(){         // 人说话是一个具体的功能
              System.out.println(this.getContent()) ;  // 输出内容
       }
       public abstract String getContent() ;     // 说话的内容由子类决定
}
class Student extends Person{
       private float score ;
       public Student(String name,int age,float score){
              super(name,age) ;   // 调用父类中的构造方法
              this.score = score ;
       }
       public String getContent(){
              return      "学生信息 --> 姓名：" + super.getName() +
                            "；年龄：" + super.getAge() +
                            "；成绩：" + this.score ;
       }
}
class Worker extends Person{
       private float salary ;
       public Worker(String name,int age,float salary){
              super(name,age) ;   // 调用父类中的构造方法
              this.salary = salary ;
       }
       public String getContent(){
              return      "工人信息 --> 姓名：" + super.getName() +
                            "；年龄：" + super.getAge() +
                            "；工资：" + this.salary ;
       }
}
public class AbstractCaseDemo02{
       public static void main(String args[]){
              Person per1 = null ;       // 声明Person对象
              Person per2 = null ;       // 声明Person对象
              per1 = new Student("张三",20,99.0f) ; // 学生是一个人
              per2 = new Worker("李四",30,3000.0f) ;     // 工人是一个人
              per1.say() ;     // 学生说学生的话
              per2.say() ;     // 工人说工人的话
       }
}

接口的实际应用——制定标准]

实例：

interface USB{             // 定义了USB接口
       public void start() ; // USB设备开始工作
       public void stop() ; // USB设备结束工作
}
class Computer{
       public static void plugin(USB usb){     // 电脑上可以插入USB设备
              usb.start() ;
              System.out.println("=========== USB 设备工作 ========") ;
              usb.stop() ;
       }
}
class Flash implements USB{
       public void start(){ // 覆写方法
              System.out.println("U盘开始工作。") ;
       }
       public void stop(){        // 覆写方法
              System.out.println("U盘停止工作。") ;
       }
}
class Print implements USB{
       public void start(){ // 覆写方法
              System.out.println("打印机开始工作。") ;
       }
       public void stop(){        // 覆写方法
              System.out.println("打印机停止工作。") ;
       }
}
public class InterfaceCaseDemo02{
       public static void main(String args[]){
              Computer.plugin(new Flash()) ;
              Computer.plugin(new Print()) ;
       }
}

工厂设计模式

实例：

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 Factory{ // 定义工厂类
       public static Fruit getInstance(String className){
              Fruit f = null ;
              if("apple".equals(className)){     // 判断是否要的是苹果的子类
                     f = new Apple() ;
              }
              if("orange".equals(className)){   // 判断是否要的是橘子的子类
                     f = new Orange() ;
              }
              return f ;
       }
}
public class InterfaceCaseDemo05{
       public static void main(String args[]){
              Fruit f = Factory.getInstance(args[0]) ; // 实例化接口
              if(f!=null){     // 判断是否取得实例
                     f.eat() ;
              }
       }
}

实例分析：宠物商店

要求：实现一个宠物商店，在宠物商店中可以有多种（由用户决定数量）宠物，试表示出此种关系，并要求可以根据宠物的关键字查找到相应的宠物信息。

代码：

interface Pet{  // 定义宠物接口
       public String getName() ;
       public String getColor() ;
       public int getAge() ;
}
class Cat implements Pet{     // 猫是宠物，实现接口
       private String name ;     // 宠物名字
       private String color ;     // 宠物颜色
       private int age ;             // 宠物年龄
       public Cat(String name,String color,int age){
              this.setName(name) ;
              this.setColor(color) ;
              this.setAge(age) ;
       }
       public void setName(String name){
              this.name = name ;
       }
       public void setColor(String color){
              this.color = color;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public String getColor(){
              return this.color ;
       }
       public int getAge(){
              return this.age ;
       }
}
class Dog implements Pet{    // 狗是宠物，实现接口
       private String name ;     // 宠物名字
       private String color ;     // 宠物颜色
       private int age ;             // 宠物年龄
       public Dog(String name,String color,int age){
              this.setName(name) ;
              this.setColor(color) ;
              this.setAge(age) ;
       }
       public void setName(String name){
              this.name = name ;
       }
       public void setColor(String color){
              this.color = color;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public String getColor(){
              return this.color ;
       }
       public int getAge(){
              return this.age ;
       }
}
class PetShop{       // 宠物商店
       private Pet[] pets ;  // 保存一组宠物
       private int foot ;
       public PetShop(int len){
              if(len>0){
                     this.pets = new Pet[len] ;       // 开辟数组大小
              }else{
                     this.pets = new Pet[1] ;  // 至少开辟一个空间
              }
       }
       public boolean add(Pet pet){ // 增加的是一个宠物
              if(this.foot<this.pets.length){
                     this.pets[this.foot] = pet ;      // 增加宠物
                     this.foot ++ ;
                     return true ;
              }else{
                     return false ;
              }
       }
       public Pet[] search(String keyWord){
              // 应该确定有多少个宠物符合要求
              Pet p[] = null ;
              int count = 0 ; // 记录下会有多少个宠物符合查询结果
              for(int i=0;i<this.pets.length;i++){
                     if(this.pets[i]!=null){            // 表示此位置有宠物
                            if(this.pets[i].getName().indexOf(keyWord)!=-1
                                   ||this.pets[i].getColor().indexOf(keyWord)!=-1){
                                   count++ ;       // 修改查找到的记录数
                            }
                     }
              }
              p = new Pet[count] ;      // 开辟指定的大小空间
              int f = 0 ;       // 增加元素的位置标记
              for(int i=0;i<this.pets.length;i++){
                     if(this.pets[i]!=null){            // 表示此位置有宠物
                            if(this.pets[i].getName().indexOf(keyWord)!=-1
                                   ||this.pets[i].getColor().indexOf(keyWord)!=-1){
                                   p[f] = this.pets[i] ;
                                   f++ ;
                            }
                     }
              }
              return p ;
 
       }
}
public class PetShopDemo{
       public static void main(String args[]){
              PetShop ps = new PetShop(5) ;     // 五个宠物
              ps.add(new Cat("白猫","白色的",2)) ; // 增加宠物，成功
              ps.add(new Cat("黑猫","黑色的",3)) ; // 增加宠物，成功
              ps.add(new Cat("花猫","花色的",3)) ; // 增加宠物，成功
              ps.add(new Dog("拉步拉多","黄色的",3)) ;       // 增加宠物，成功
              ps.add(new Dog("金毛","金色的",2)) ;       // 增加宠物，成功
              ps.add(new Dog("黄狗","黑色的",2)) ;       // 增加宠物，失败
              print(ps.search("黑")) ;
       }
       public static void print(Pet p[]){
              for(int i=0;i<p.length;i++){
                     if(p[i]!=null){
                            System.out.println(p[i].getName() + "，" + p[i].getColor()
                                   +"，" + p[i].getAge()) ;
                     }
              }
       }
}

Object类

在JAVA中一切的类都是以继承的关系存在的，如果一个类在定义时没有明确的指名继承哪个类，则默认继承Object类。

JAVA中所有的类都有一个公共的父类就是Object，一个类只要没有明显的继承一个类，则肯定是Object类的子类。

equals()方法

equals()方法的主要功能是进行对象的比较操作

String本身也是Object类的子类，所以已经覆写了此方法

包装类

Java中许多存储和管理对象集合的有用的类（列表、树、数组等）不能在这些基本类型上进行操作，因为从技术上讲这些基本类型不是从Java对象类派生出来的。但是Java为基本类型提供包装类，这使得任何接受对象的操作也可以用来操作基本类型。直接将简单类型的变量表示为一个类，在执行变量类型的相互转换时，我们会大量使用这些包装类。 Java共有六个包装类，分别是Boolean、Character、Integer、Long、Float和Double，除了首字母大写之外，包装类与基本类型名字相似。

匿名内部类

在一个类的内部还有另外一个类称为内部类，那么匿名内部类是如果一个类在整个操作中只使用一次的话，就可以将其定义成匿名内部类，匿名内部类是在抽象及接口的基础上发展起来的。

曹文涛

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 基础面向对象高级

面向对象高级继承的基本实现在JAVA中使用extends关键字完成类的继承关系，格式：class 父类{} //定义父类class 子类 extends 父类{} //使用extends关键字实现继承继承：子类继承父类，可以扩展已有类的功能。继承的限制在JAVA中只允许单继承，不能使用多重继承，即：一个子类只能继承一个父类。但
复制链接

扫一扫