多态
public class Person {
public void run(){
System.out.println("run");
}
}
/**
* 多态注意事项
* 多态是方法的多态，属性没有多态
* 父类和自雷，有联系 ；类型转换异常！ClassCastException
* 存在条件 继承关系，方法需要重写 父类引用指向子类对象 father f1=new Son()
* static final private 不可重写
*/
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();//子类重写了父类的方法，执行子类的方法
s1.run();
s1.eat();
}
}
package 多态;
public class Student extends Person{
public void run(){
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
类型装换
instanceof
public class Application {
public static void main(String[] args) {
//类型之间的转化
Person student=new Student();
((Student) student).go();
//子类转化为父类可能会丢失一些方法
//父类引用指向子类对象
Person person=student;
//向下转型 强制转换
}
}
/**
* //Object>String
* //Object>Person
* //Object object=new Student();
* System.out.println(object instanceof Student);
* System.out.println(object instanceof Person);
* System.out.println(object instanceof Teacher);
* System.out.println(object instanceof Object);
* System.out.println(object instanceof String);
* System.out.println("---------");
* Person person=new Student();
* System.out.println(person instanceof Student);
* System.out.println(person instanceof Person);
* System.out.println(person instanceof Teacher);
* System.out.println(person instanceof Object);
* //System.out.println(person instanceof String);
* // System.out.println(X instanceof Y);能不能编译通过，判断X、Y之间是否有关系
* Student student =new Student();
* System.out.println(student instanceof Student);
* System.out.println(student instanceof Person);
* System.out.println(student instanceof Object);
*/
static
package 关键字;
import static java.lang.Math.random;//静态导入包
public class Demo01 {
private static int age;//静态的变量 多线程
private double score ;//非静态的变量
public static void main(String[] args) {
Demo01 demo01=new Demo01();
// System.out.println(demo01.age);
// System.out.println(demo01.score);
// System.out.println(Demo01.age);
System.out.println(random());
}
//非静态可以调用静态
public void run(){
}
//静态代码块
static{
//类一加载就执行 在构造方法前，只执行一次
System.out.println("静态代码块");
//静态代码块>匿名代码块>构造方法
}
public Demo01(){
System.out.println("构造方法");
}
}
抽象类
public abstract class Action {
//abstract变为抽象类
//抽象方法 只有方法的名字，没有方法的实现
public abstract void doSomething();
//一旦有抽象方法就必须为抽象类
//抽象类不能new，只能靠子类去实现它：约束！
//抽象的抽象：约束~
}
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法 除非子类也为抽象
//接口可以多继承 好比插座 约束插头样式，而不管多少个插头
public class A extends Action {
@Override
public void doSomething() {
}
//抽象类不能new，只能靠子类去实现它：约束！
}
抽象类为单继承
接口
package 接口;
public interface Userservice {
//接口中定义的变量都为常量
//接口中所有定义都是抽象的 public
public abstract void run();
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
/**
* 普通类：只有具体实现
* 抽象类：集体实现和规范（抽象方法）都有
* 接口：只有规范！自己无法写方法 约束和实现分离 ：面向接口编程
*/
/*
1.约束
2.定义一些方法，让不同的人实现
3.public abstract
4.public stativ final
5.接口不能被实例化，接口中没有构造方法
6.implements可以实现多个接口，但必须重写接口中的方法
*/
package 接口;
//抽象类 ：extends
//类可以实现接口 implements
//实现了接口中的类必须要重写方法
//利用接口实现多继承
public class UserServiceImpl implements Userservice,TimeService{
@Override
public void run() {
}
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
package 接口;
public interface TimeService {
void timer();
}
内部类
package 内部类;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getId(){
System.out.println(id);
}
}
}
package 内部类;
public class Application {
public static void main(String[] args) {
//
Outer outer=new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getId();
}
}
package 内部类;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
class B{
//局部内部类
public void in(){
}
}
}
public static class Inner{//静态内部类无法访问非静态属性
public void in(){
System.out.println("这是内部类的方法");
}
}
public static void main(String[] args) {
new A().eat();//没有名字初始化类 匿名对象的使用即不用将实例保存到变量中
new UserService(){
@Override
public void hello() {
}
};
}
}
//一个java文件中可以有多个class但是只能有一个public
class A{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}