面向对象 oop 2

面向对象 oop 2

1.继承

1.继承的本质是对某一批类的抽象 .

2.extends的意思是 "扩展". 子类是父类的扩展

3.Java中只有单继承 ,没有多继承

 

1.继承是类和类之间的一种关系. 除此之外,类和类之间的关系还有依赖,组合.聚合的关系.

2.继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示

3.子类和父类之间,从意义上讲应该具有"is a"的关系


在java中,所有的类都默认直接或间接继承object类

面向对象 oop 2

 

 

如果父类是私有 private 像继承就要调用

1.Supen详解

面向对象 oop 2

 

面向对象 oop 2

super注意点

1.super调用父类的构造方法,必须在构造方法的第一个

2.super必须只能出现在子类的方法或构造器方法中

3.super 和 this 不能 同时调用 构造方法

 

this

代表对象不同:

this:本身调用者这个对象

super:代表父亲类对象的应用

 

前提

this :没有继承也可以使用

super:只能在有继承条件才可以使用

 

构造方法

this();本类的构造

super();父类的构造

面向对象 oop 2

先执行父类的 在执行子类的 相当于在子类的无参上隐藏了一个super 指向父类的无参

2.方法的重写

面向对象 oop 2

面向对象 oop 2

 

 

重写:需要有继承关系,子类重写父类的方法

1.方法名必须相同

2.参数列表 列表必须相同

3.修饰符:范围可以扩大但不能缩小

4.抛出的异常:范围.可以被缩小,但不能扩大

5.静态的方法和非静态的方法区别很大

6.重写只能重写非静态 有static是静态不能重写

重写.子类的方法和父类要一致:方法体不同!

重写 CTRL+o

2.多态

多态注意事项:

1.多态是方法的多态,属性没有多态

2.父亲和子类,有联系 类型转换异常! classcastException

3.存在条件:继承关系,方法需要重写,父类引用指向子类对象!

1. instancedof和 类型转换

package com.Java.oop4;
public class Application {
   public static void main(String[] args) {
       Object object= new Student();
       System.out.println(object instanceof Student);//true
       System.out.println(object instanceof Object);//true
       System.out.println(object instanceof Teacher);//false
       System.out.println(object instanceof Person);//true
       System.out.println(object instanceof String);//false
       System.out.println("==========================");
        Student student= new Student();
       System.out.println(student instanceof Student);//true
       System.out.println(student instanceof Object);//true
       //System.out.println(student instanceof Teacher);//编译报错
       System.out.println(student instanceof Person);//true
       //System.out.println(student instanceof String);//编译报错
       System.out.println("==========================");
       Person person= new Student();
       System.out.println(person instanceof Student);//true
       System.out.println(person instanceof Object);//true
       System.out.println(person instanceof Teacher);//false
       System.out.println(person instanceof Person);//true
     //System.out.println(person instanceof String);//编译报错
  }
}
package com.Java.oop4;
public class Application {
   public static void main(String[] args) {
       //类型之间的转化;父   子
     //高                     低
      Person JPG = new Student();
      //student 将这个对象转换为Student类型,我们就可使用Student类型的方法了!
      ((Student)JPG).son();
  }
}

1.父类引用指向子类的对象

2.把子类转换为父类,向上转型:

3.把父亲转换为子类,向下转型: 强制转换

4.方便方法的调用,减少重复的代码!简介

2. static

package com.Java.Static;
//static
public class Student {
    private static int age;//静态的变量
    private double score;//非静态的变量
   public static void main(String[] args) {
       Student S1 = new Student();
       System.out.println(Student.age);
       System.out.println(S1.age);
       System.out.println(S1.score);
  }
}
package com.Java.Static;
public class Student {
   //2
  {
       System.out.println("匿名代码块");
  }
   // 1   : 只执行一次
   static{
       System.out.println("静态代码块");
  }
   //3
   public Student() {
       System.out.println("构造方法");
  }
   public static void main(String[] args) {
       Student student = new Student();
  }
}

final 定义了的 就不能被继承了

3.抽象类

1.abstract修饰符可以用来修饰方法也可以修饰类 ,如果修饰方法,那么该方法就是抽象方法:如果修饰类,那么该类就是抽象类

2.抽象类.不能使用new关键字 来创建对象,他是用来让子类继承的

3.抽象方法,只有方法的声明,没有方法的实现 它是用来让子类实现的

4.子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类

package com.Java.Static;
?
public class Choxiang {
   //abstract 抽象类:类 extends:单继承 ~ (接口可以多继承)
   public abstract class Action{
       //约束~ 有人帮我们实现
       //abstract,抽象方法,只有方法名字,没有方法的实现
       public abstract void doSomething();
       // 1.不能new 这个 抽象类,只能靠类去实现它
       // 2.抽象类中可以写普通的方法
       //3.抽象方法必须在抽象类中
      }
  }

4.接口

1.普通类: 只有具体实现

2.抽象类:具体实现和规范(抽象方法)都有!

接口:只有规范!自己无法写的方法~装也的约束!约束个实现分离:面向接口编程

interface


作用

1.约束

2.定义了一些方法,让不同的人实现~

3.public abstract

4.public static final

5.接口不能被实例化~ 接口中没有构造方法

6.implements 可以实现多个接口

7.必须要重写接口中的方法


package com.Java.JieKo;
//抽象类 :extends~
//类 可以实现接口 implements 接口
//实现了接口的类, 就需要重写接口中的方法
//多继承 ~ 利用接口的多继承
public class UserServiceImpl implements UserService,TimeService {
   @Override
   public void add(String name) {
  }
   @Override
   public void query(String name) {
  }
   @Override
   public void update(String name) {
  }
   @Override
   public void delete(String name) {
  }
   @Override
   public void time() {
  }
}
package com.Java.JieKo;
//interface 定义的关键字   接口都需要一个实现类
public interface UserService {
   //接口中所有定义其实都是抽象的 public
   //可以直接写 返回值类型 和方法名
     void add(String name);
     void delete(String name);
     void update(String name);
     void query(String name);
}
package com.Java.JieKo;
?
public interface TimeService {
   void time();
?
}

 

 

 

 

 

 

 

 

 

 

面向对象 oop 2

上一篇:ES6 迭代器简述


下一篇:LeetCode-018-四数之和