Java教程

Java学习第十三天<instance of><static 关键字详解><抽象类><接口的定义与实现><N中内部类>

本文主要是介绍Java学习第十三天<instance of><static 关键字详解><抽象类><接口的定义与实现><N中内部类>,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

instance of

package com.oop.demo06;
​
public class Teacher extends Person{
​
}

 

package com.oop.demo06;
​
public class Person {
    public void run(){
        System.out.println("run");
    }
}

 

package com.oop.demo06;
​
public class Studenr2 extends Person{
    public void go(){
        System.out.println("go");
    }
}
/*测试
 //Object>String
        //Object>Person>Teacher
        //Object>Person>Student2
        //System.out.println(x instanceof y);判断x与y是否存在父子关系 左边类名级别决定能跟哪一级编译判断,不能和并列级判断
        Object studenr1 = new Studenr2();
        System.out.println(studenr1 instanceof Studenr2);
        System.out.println(studenr1 instanceof com.oop.demo06.Person);
        System.out.println(studenr1 instanceof Object);//true
        System.out.println(studenr1 instanceof com.oop.demo06.Teacher);//false
        System.out.println(studenr1 instanceof String);
        System.out.println("===============================================");
       com.oop.demo06.Person person1 = new Studenr2();
        System.out.println(person1 instanceof Studenr2);
        System.out.println(person1 instanceof com.oop.demo06.Person);
        System.out.println(person1 instanceof Object);//true
        System.out.println(person1 instanceof com.oop.demo06.Teacher);//false
        //System.out.println(person1 instanceof String); 编译就报错
        System.out.println("===============================================");
        com.oop.demo06.Studenr2 student2 = new com.oop.demo06.Studenr2();
        System.out.println(student2 instanceof Studenr2);
        System.out.println(student2 instanceof com.oop.demo06.Person);
        System.out.println(student2 instanceof Object);//true
        //System.out.println(student2 instanceof com.oop.demo06.Teacher);//编译就报错
        //System.out.println(student2 instanceof String); //编译就报错
​
        //类型之间转化:基本类型 高低64 32 16 8 / 父 子
        //将person1这个对象转化为Studenr2类型,就可以使用Studenr2的方法了,高转低要强转
        //子类转化为父类,可能丢失一些方法
        ((Studenr2) person1).go();
 */
/*
1.父类引用指向子类对象,反之不行
2.子类转为父类,不用强转,会丢失方法
3.父类转为子类,要强转
4.方便方法调用,减少重复代码,不用再重新new一个类,把原来的降级或升级可以调用其他方法
面向对象特征:封装、继承、多态 都是为了抽象(编程思想)
 */

 

static 关键字详解

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) {
        Student s1 = new Student();
        System.out.println(Student.age);//类变量(静态变量推荐用类名.变量,非静态变量(score)不能这样访问)
        System.out.println(s1.age);//对象调用变量
        System.out.println(s1.score);
​
        new Student().run();//静态方法可调用静态方法,不能调用普通方法(静态与类一起加载,加载之前没有普通类),需要new
        Student.go();//go();
​
​
    }
​
}

 

package com.oop.demo07;
​
public class Person {
    {
        //2.代码块(匿名代码块)构造器之前,用来赋初始值
        System.out.println("匿名代码块");
    }
    static{
        //1.静态代码块,加载初始化数据,与类一起加载,只执行一次
        System.out.println("静态代码块");
    }
​
    public Person() {//3.构造器
        System.out.println("构造方法");
    }
​
    public static void main(String[] args) {
        Person person1 = new Person();//调用非静态加new
        System.out.println("===================");
        Person person2 = new Person();//static只执行一次
​
    }
}

 

package com.oop.demo07;
​
import static java.lang.Math.random;//静态导入包
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}
//final修饰类 无父子关系

 

抽象类

package com.oop.demo08;
//抽象类 本质是类需要继承 extend:单继承  (接口可以多继承)
public abstract class Action {
    //只有约束~不写方法体,有人帮我们实现
    public abstract void doSomething();//抽象方法,只有方法名,没有方法实现
​
​
}
/*抽象类
1.不能new,只能靠子类实现
2.抽象类可以写普通方法,可以写抽象方法,但有了抽象方法必包含于抽象类
3.抽象的抽象:约束
思考题
1.存在构造器吗,存在
2.存在的意义是什么 抽象共有属性,重写方法,提高开发效率,可扩展性
 */

 

package com.oop.demo08;
//抽象类的所有方法必须要由子类实现,除非子类也抽象,需要子子类实现
public class A extends Action{
​
    @Override
    public void doSomething() {
​
    }
}

 

接口的定义与实现

package com.oop.demo09;
//锻炼抽象思维
//接口 interface定义关键词 接口都需要实现类
public interface UserService{
    //接口中所有定义的方法都是抽象的 简写 返回值类型+方法名
    void run(String name);//public abstract void run();
    void delete(String name);
    void update(String name);
    void query(String name);
    //接口中所有定义的属性都是常量 public static final 
    int AGE=99;
    
    
}

 

package com.oop.demo09;
​
public interface TimeService {
    void timer();
​
}

 

package com.oop.demo09;
//类可以实现接口 implements接口(多个)  extends抽象类(单继承)
//实现接口,需要重写接口中方法
public class UserServiceImpl implements UserService,TimeService{//alt+回车
​
    @Override
    public void run(String name) {
​
    }
​
    @Override
    public void delete(String name) {
​
    }
​
    @Override
    public void update(String name) {
​
    }
​
    @Override
    public void query(String name) {
​
    }
​
    @Override
    public void timer() {//多继承
​
    }
}

 

接口的作用:
1.约束
2.定义一些方法,让不同的人实现
3.方法都是 public abstract
4.常量都是 public static final
5.接口不能被实例化,接口中没有构造方法(接口不是类,不能new)
6.implements可实现多个接口
7.必须要重写接口中方法

 

N中内部类

成员内部类、静态内部类、局部内部类、匿名内部类

package com.oop.demo10;
​
public class Outer {
​
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{//加static变静态内部类,与类一起加载
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //内部类获得外部类的私有属性
        public void ID(){
            System.out.println(id);
        }
    }
​
    public void method(){
        class Inner2{ //局部内部类
            public void in(){
​
            }
        }
    }
}
//一个java类中有多个class类,但只能有一个public class类
class A {
    public static void main(String[] args) {
​
    }
}
/*
 Outer outer = new Outer();
        outer.out();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.ID();
 */

 

package com.oop.demo10;
​
public class Test {
    public static void main(String[] args) {
        new Apple().eat();//没有名字初始化类,不用把实例保存到变量中
        new UserService() {//匿名内部类
            @Override
            public void hello() {
​
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
     void hello();
}
这篇关于Java学习第十三天<instance of><static 关键字详解><抽象类><接口的定义与实现><N中内部类>的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!