java基础终稿

多态

---

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();
}