面向对象（下）

一.类的继承

class 父类{

.......

class 子类 extends 父类{

.........

}

例如：

public class zz {
         String name;
         int age;

         public String getName() {
             return name;

         }
         public void setName(String name) {
this.name=name;
         }
         public int  getAge() {
             return age;

         }
         public void setAge(int age) {
             this.age=age;
         }

     }
    class dog extends zz {
    }
   class ss{
         public static void main(String[] args) {
             dog hh =new dog();
             hh.setName("张三");
             hh.setAge(18);
             System.out.println("我的名字"+ hh.name+"年龄"+ hh.age);

         }
     }

注意：1.一个子类只能继承一个父类2.一个父类可以有多个子类3.父类可以是其它类的子类       

二.方法的重写

package ww;

class Aniaml {
    void read(){
        System.out.println("我会说英文");
    }
}
    class kk extends Aniaml{
        void read(){//方法重新，方法名与外部类方法名相同
            System.out.println("我会说英文，也会说中文");
        }
    }
    class rr{
        public static void main(String[] args) {
           kk c = new kk();
           c.read();

    }

 

 

三.super关键字......继承是桥梁，super是调用
super与this相似
使用super关键字可以调用父类中成员变量，成员方法，构造方法
super.成员方法（参数1，参数2）
super.成员变量
super（参数1，参数2）//构造方法

A.成员方法
package ww;
class Aniaml {
    void read(){
        System.out.println("我会说英文");
    }
}
    class kk extends Aniaml{
      
        public void read(){//调用成员方法
            super.read();//调用成员方法
            System.out.println("也会说中文");
        }

    }
    class rr{
        public static void main(String[] args) {
           kk c = new kk();
           c.read();
    }
}

 

 

B.构造方法
例如1：
package ww;

//super关键字
 class ll {
   private  String name;//reture--getxxx,setxxx.....private
   private  int age;
   public ll(String name,int age){
       this.name=name;
       this.age=age;
   }
   //reture 返回
   public String getName(){
       return name;
   }
   public void setName(String name){
       this.name=name;
   }
   public int getAge(){
       return age;
   }

    public void setAge(int age) {
        this.age = age;

        }
    public String info(){
        return"名称："+this.getName() +",年龄："+this.getAge();

    }
}
 class cc extends ll{
  private   String colour ;
     public cc(String name,int age,String colour){
         super(name,age);//调用构造方法
         this.colour=colour;
     }
     //reture返回
     public String getColour(){
         return colour;
     }
     public void setColour(String colour){
         this.colour=colour;
     }
     public String info(){//方法重构
         return super.info()+"颜色"+colour;
     }
}
//检测
 class vv{
    public static void main(String[] args) {
        cc gg = new cc("张三",12,"蓝色");
        System.out.println(gg.info());
    }
例如2package study;

//super调用构造方法
 class study3 {
  private String name;
  private  int age;
  //构造方法
 public study3(String name,int age){
  this.name=name;
  this.age=age;
 }
 //reture返回
 public String getName(){
  return name;
 }
 public void setName(String name){
  this.name=name;
 }
 public int getAge(){
  return age;
 }
 public void setAge(int age){
  this.age=age;
 }
 //public String info(){
 // return "名称"+this.getName()+"年龄"+this.getAge();
 //}
}
//继承
class kk extends study3{
 private   String school;//static静态属性
 public kk(String name,int age,String school){
  super(name,age);
  this.setSchool(school);
}
public String getSchool(){
  return school;
}
public void setSchool(String  school){
  this.school=school;
}
void raad(){
 System.out.println("我的姓名是"+getName()+"我的年龄是"+getAge()+"我的学校是"+school);
}
}
class vv{
 public static void main(String[] args) {
  kk vv1 = new kk("张三",12,"山东商务职业学院");
  vv1.raad();
 }
}
四.final关键字
 在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）
注意：1.当用final修饰一个类时，表明这个类不能被继承。
       2.修饰方法不能被子类重写
       3.修饰变量，成员变量，成员方法是常量，不能被修改

1.修饰类

package study;

final class study5 {
    int age ;
    String name;
}
class dd extends study5{//报错
    
}

2.修饰方法

package study;

 class zmh {
     final void read(){
         System.out.println("张翰林是小狗");
     }
}
class zhl extends zmh{
     void read(){//报错
         System.out.println("你说的对");
     }
}
class bb5{
    public static void main(String[] args) {
        zhl dd= new zhl();
        dd.read();
    }
}

3.修饰变量

package study;

 class study5 {
     public static void main(String[] args) {
         final int age =18;
         int age=12;//报错
     }
}

五.抽象类与接口

1.抽象类
A.抽象方法的 3 个特征如下：

1. 抽象方法没有方法体（代码），方法直接用分号结束
2. 抽象方法必须存在于抽象类中
3. 子类重写父类时，必须重写父类所有的抽象方法
4. 抽象类必须是父类

B.使用规则：

1. 抽象类和抽象方法都要使用 abstract 关键字声明。
2. 如果一个方法被声明为抽象的，那么这个类也必须声明为抽象的。而一个抽象类中，可以有 0~n 个抽象方法，以及 0~n 个具体方法。
3. 类不能实例化，也就是不能使用 new 关键字创建对象。
4. 包含抽象方法的类必须是抽象类
5. 如果一个类继承了抽象类那么该子类必须实现抽象类中所以抽象方法（重写方法）

C.注意：在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰（子类是无法重写的）不能使用static（通过类名调用无意义），不能使用finaD.抽象方法具体格式：

abstract 返回值类型 方法名称（参数）；
抽象类格式：
abstract class 抽象类名称　　
2.接口
如果一个抽象类都是抽象方法，则可以将这个类定义接口,一个接口可以继承多个父类
接口使用interface关键字声明（继承抽象类），格式如下
interface 接口名称 {
 // 声明变量 
// 抽象方法 }
定义接口的实现类，语法格式：
修饰符 class 类名 implements 接口1，接口2.....{

 

 

 注意：接口中变量默认是 public static final ，接口中的方法默认是public abstract，即抽象方法。若接口声明为public则接口中使用方法要使用public

 

六.多态
1.概述
不同对象调用一个方法时表现的不同行为，父类为抽象类，父类方法为抽象方法
两种形式：1.方法的重载         2.对象的多态性（重写）

package Learn;
abstract class learn3 {
abstract void shout() ;

}
class dog extends learn3 {
void shout() {System.out.println("汪汪汪");};

}
class cat extends learn3{
void shout() {
System.out.println("喵喵喵喵");
}
}
class bb {
public static void main(String[] args) {
learn3 cc =new dog() ;//创建dog对象
learn3 cc2 =new cat() ;//创建cat对象
cc.shout();
cc2.shout();
}
}

2.对象类型的转换

两种情况：区别（向上转移是父类调用子类重写方法，行为有限，向下转移是子类调用子类方法，行为多）

向上转换（父类对象调用子类重写方法）：子类对象--父类对象

格式：父类类型  父类对象 = 子类实例

Animal a = new Cat（）；

向下转换（子类对象调用子类中方法）：父类对象--子类对象

格式：父类类型 父类对象 = 子类实例

         子类类型 子类对象 =（子类类型）父类对象

Animal a = new Cat（）；

Cat c =（Cat)a

向上转换：（父类对象调用子类重写方法）

package Learn;
abstract class learn3 {
abstract void shout() ;

}
class dog extends learn3 {
void shout() {System.out.println("汪汪汪");};

}
class cat extends learn3{
void shout() {
System.out.println("喵喵喵喵");
}
}
class bb {
public static void main(String[] args) {
learn3 cc =new dog() ;//创建dog对象。向上转换类型
learn3 cc2 =new cat() ;//创建cat对象。向上转换类型
cc.shout();//输出子类重写内容
cc2.shout();//输出子类重写内容
}
}

向下转换类型：（子类对象调用子类中方法）

package cc;
class Animal {
    void read(){
        System.out.println("汪汪汪");
    }
}
 class  cat extends Animal {
    //重写
       void read(){
         System.out.println("喵喵喵喵喵");
     }
     void eat(){
         System.out.println("骨头");
     }
}
//测试
 class cc1{
    public static void main(String[] args) {
        Animal an =new cat();
        cat an1 =(cat)an;
        an1.read();
        an1.eat();

    }
}
3.instanceof关键字
判断一个对象是否是某个类或者接口的实例
语法格式：对象 instanceof类（接口）

package cc;
class Animal {
    void read(){
        System.out.println("汪汪汪");
    }
}
 class  cat extends Animal {
    //重写
       void read(){
         System.out.println("喵喵喵喵喵");
     }
     void eat(){
         System.out.println("骨头");
     }
}
//测试
 class cc1{
    public static void main(String[] args) {
        Animal an =new cat();//向上转换
        System.out.println(" Animal an =new cat();"+(an instanceof Animal));//检测

    }
}

七.object类
三个方法

Boolean equals（）       int hashCode（）             String toString

判断两个对象是否相等        返回对象的散列码值             返回对象的字符串表示形式

toString（）方法的使用1：

package cc;
 class aa {
     void read(){
         System.out.println("定位");
     }
}
class bb {
    public static void main(String[] args) {
        aa cc = new aa();
        System.out.println(cc.toString());//toString输出形势

    }
}
toString使用2：

package cc;

 class aa {
     public String toString(){
         return "这是一个单位";//reture 可任意返回（可以是变量，也可以是字符串，也可以计算）
     }
}
class ee{
    public static void main(String[] args) {
        aa ff = new aa();
        System.out.println(ff.toString());//toString()方法输出形势。
    }
}
八.reture
return 关键字并不是专门用于结束循环的，return 语句用于终止函数的执行或退出类的方法，并把控制权返回该方法的调用者。如果这个方法带有返回类型，return 语句就必须返回这个类型的值；如果这个方法没有返回值，可以使用没有表达式的 return 语句。
如果一个方法使用了 return 语句并且后面跟有该方法返回类型的值，那么调用此方法后，所得到的结果为该方法返回的值。
reture可以返回字符串，可以返回常量（运算）结果，访问器，也可以进行计算......