面向对象 oop 2
1.继承
1.继承的本质是对某一批类的抽象 .
2.extends的意思是 "扩展". 子类是父类的扩展
1.继承是类和类之间的一种关系. 除此之外，类和类之间的关系还有依赖，组合.聚合的关系.
2.继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示
3.子类和父类之间，从意义上讲应该具有"is a"的关系
在java中，所有的类都默认直接或间接继承object类
如果父类是私有 private 像继承就要调用
1.Supen详解
super注意点
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或构造器方法中
3.super 和 this 不能 同时调用 构造方法
this
代表对象不同：
this：本身调用者这个对象
super：代表父亲类对象的应用
前提
this ：没有继承也可以使用
super：只能在有继承条件才可以使用
构造方法
this();本类的构造
super();父类的构造
先执行父类的 在执行子类的 相当于在子类的无参上隐藏了一个super 指向父类的无参
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 {
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();
}
