package com.oop.demo06;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指定的引用类型就不确定了：父类的引用指向子类
//
// //Student 能调用的方法都是自己的或者继承父类的
// Student s1 = new Student();
// //Person 父类型，可以指向子类，但是不能调用子类独有的方法
//// Person s2 = new Student();
// Object s3 = new Student();
// //对象能执行哪些方法，主要看对象左边的类型和右边关系不大！
// s2.run();//子类重写了父类的方法，执行了子类的方法
// //s2.eat();
//// ((Student) s2).eat();//强转
// s1.run();//
// s1.eat();
}
}
//
package com.oop.demo06;
public class Person {
public void run() {
System.out.println("run");
}
}
/*
多态的注意事项：
1.多态是方法多态，属性没有多态
2.父类和子类有联系， 类型转换异常！ ClassCastException！
3.多态存在条件：
（1）继承关系
（2）方法需要重写
（3）父类的引用指向子类对象！Father f1 = new Son();
1.static 方法，属于类，它不属于实例
2.final 常量
3.private 方法：私有的
instanceof （类型转换） 引用类型
*/
//
package com.oop.demo07;
public class Person {
//2:赋初始值---加载顺序
{
//代码块（匿名代码块）
System.out.println("匿名代码块");
}
//1.只执行一次--加载顺序
static {
//静态代码块
System.out.println("静态代码块");
}
//3--加载顺序
public Person(){
System.out.println("构造方法");
}
//4--加载顺序
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("=========");
Person person2 = new Person();
}
}
//
package com.oop.demo07;
//static关键字(静态)
public class Student {
private static int age;//静态的变量
private double score;//非静态的变量
public void run(){
go();
}
public static void go(){
}
public static void main(String[] args) {
go();
}
}
//
package com.oop.demo07;
import static java.lang.Math.PI;
import static java.lang.Math.random;//静态导入包
public class Test {
public static void main(String[] args) {
System.out.println(Math.random());
System.out.println(PI);
}
}
//
package com.oop.demo08;
//抽象类的所有方法，继承了它的子类，都必须要实现它的所有方法
public class A extends Action{
public void doSomething() {
}
}
//
package com.oop.demo08;
//抽象类：类 extends -- 单继承 （接口可以多继承)
public abstract class Action {
//约束--有人帮我们实现
//abstract,抽象方法，只有方法名字，没有方法的实现
public abstract void doSomething();
//1.不能new这个抽象类，只能靠子类去实现它，约束！
//2.抽象类中可以写普通的方法
//3.抽象方法必须在抽象类中
//抽象的抽象：约束
//抽象类中可以用new 对象？ 存在构造方法？
//存在的意义 ---抽象出来，提高开发效率
}
//
接口作用：
1.约束
2.定义一些方法，让不同的人实现
3.接口中的方法都是抽象的public abstract（编写时一般省略public abstract，系统自动识别，写出来也是灰色的）
4.接口中定义的常量都是public static final
5.接口不能被实例化~,接口中没有构造方法
6.接口可以被多实现，实现接口的关键字，implements
7.实现接口的类，必须要重写接口中的方法
//
package com.oop.demo09;
/*
抽象类：extends
类，可以实现接口，implements 接口
实现了接口的类，就需要重写接口中的方法
*/
//多继承-利用接口是实现多继承
public class UserServiceImpi implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void check(String name) {
}
@Override
public void time() {
}
}
//
package com.oop.demo09;
//接口 关键字interface，接口只定义一些方法，接口都需要实现类来实现定义的这些抽象方法
/*
声明类的关键字是class，声明接口的关键字是interface
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！自己无法写方法-专业的约束！约束和实现分离：---面向接口编程
接口的本质是契约
*/
public interface UserService {
//接口中的所有定义其实都是抽象的 public abstract
// public abstract void run(String name);
//常量~public static final
int AGE = 99;//一般不会在接口中定义常量
void add(String name);//增
void delete(String name);//删
void update(String name);//改
void check(String name);//查
}
//
package com.oop.demo09;
public interface TimeService {
void time();
}