首页 > 编程语言> > Java06面向对象03

Java06面向对象03

2021-09-10 14:31:25 作者：互联网

Java06面向对象03

instanceof 类型转换

判断是否存在父子关系：
1.必须相关的类才能判断
2.x instanceof Y：判断对象X是否是类Y的子类：true,false
3.Object o=new Student：对象o的类型看右边

package com.mingmao.javaobjectoriented.programming.instanceofcode;

public class Person {
}

package com.mingmao.javaobjectoriented.programming.instanceofcode;

public class Student extends Person {
}

package com.mingmao.javaobjectoriented.programming.instanceofcode;

public class Teacher extends Person {
}

package com.mingmao.javaobjectoriented.programming;

import com.mingmao.javaobjectoriented.programming.instanceofcode.Person;
import com.mingmao.javaobjectoriented.programming.instanceofcode.Student;
import com.mingmao.javaobjectoriented.programming.instanceofcode.Teacher;

public class Application {
    public static void main(String[] args) {
        //Object-Person-Student
        //Object-Person-Teacher
        //Object-String
        Object object=new Student();

        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

        Person person=new Student();
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//报错

        Student student=new Student();
        System.out.println(student instanceof Object);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Student);//true
        //System.out.println(student instanceof Teacher);//报错
    }
}

类型转换：

package com.mingmao.javaobjectoriented.programming.instanceofcode;

public class Person {
    public void run(){
        System.out.println("run=>person");
    }
}

package com.mingmao.javaobjectoriented.programming.instanceofcode;

public class Student extends Person {
    public void go(){
        System.out.println("go=>student");
    }
}

package com.mingmao.javaobjectoriented.programming;

import com.mingmao.javaobjectoriented.programming.instanceofcode.Person;
import com.mingmao.javaobjectoriented.programming.instanceofcode.Student;

public class Application {
    public static void main(String[] args) {
        //类型之间的转换:低转高，自动；高转低，强制

        //高转低-强制
        //自动转换
        Person person = new Student();
        //强制转换
        Student student = (Student) person;
        student.go();
        ((Student)person).go();

        //低转高-自动转换
        //会丢失一些方法
        Student s=new Student();
        //自动转换
        Person p=student;
        s.go();
        //p.go();报错
    }
}

static关键字

静态属性和方法可以直接通过类名调用

package com.mingmao.javaobjectoriented.programming.staticcode;

public class Student {
    //属性
    private static int age;
    private double score;

    //方法
    public static void go(){
        System.out.println("go");
    }
    public void run(){
        System.out.println("run");
    }

    public static void main(String[] args) {
        //调用静态变量两种方法
        System.out.println(Student.age);
        Student s1=new Student();//直接通过类调用
        System.out.println(s1.age);//创建对象调用

        //调用非静态变量只有一种方法
        Student s2=new Student();
        System.out.println(s2.score);//创建对象调用

        //调用静态方法的两种方法
        Student.go();//通过类调用
        Student s3=new Student();//创建对象调用
        s3.go();

        //调用非静态方法只有一种方法
        Student s4=new Student();//通过创建对象调用
        s4.run();
    }
}

静态代码块

package com.mingmao.javaobjectoriented.programming.staticcode;

public class Person {
    //静态代码块-只加载一次
    static {
        System.out.println("静态代码块");
    }

    //匿名代码块
    {
        System.out.println("匿名代码块");
    }

    //构造方法
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person=new Person();
        //静态代码块
        //匿名代码块
        //构造方法
        Person person1=new Person();
        //匿名代码块
        //构造方法
    }
}

静态导入包：可以实现调用其他类的静态方法不加类名直接调用：
被final修饰的类不能继承

package com.mingmao.javaobjectoriented.programming.staticcode;

import static java.lang.Math.random;

public class Test {
    public static void main(String[] args) {
        //返回一个随机数，正常调用random
        System.out.println(Math.random());

        //静态导入包后，调用random
        System.out.println(random());
    }
}

抽象类

package com.mingmao.javaobjectoriented.programming.abstractclass;

//抽象类,用来被继承，不能创建对象，单继承
//有抽象方法的类必须定义为抽象类
//可以有抽象方法和普通方法
//凡是继承此类的子类都必须重写此类中的抽象方法,除非子类也是抽象类
public abstract class Action {
    //抽象方法,只有方法名，没有方法实现
    public abstract void doSomething();
}

package com.mingmao.javaobjectoriented.programming.abstractclass;

public class A extends Action {
    @Override
    public void doSomething() {

    }
}

接口

package com.mingmao.javaobjectoriented.programming.interfacecode;

//接口,都需要有实现类，可以多继承
//实现类必须实现接口中的所有方法
//接口中的所有方法都默认是public abstract 的
//接口中所有属性都默认是public static final,所以必须赋值
public interface UserService {
    //属性，一般不会在接口中定义属性
    int age=12;


    //定义方法
    void run(String a);
    //定义增删改查
    void add(String name);
    void delete(String  name);
    void update(String name);
    void query(String name);


}

package com.mingmao.javaobjectoriented.programming.interfacecode;

public interface TimeService {
    void timer();
}

package com.mingmao.javaobjectoriented.programming.interfacecode;

//接口的实现类,可实现多继承
public class UserServiceImpl implements UserService,TimeService {
   //重写UserService中的方法
    @Override
    public void run(String a) {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    //重写TimeService中的方法
    @Override
    public void timer() {

    }
}

内部类

成员内部类

package com.mingmao.javaobjectoriented.programming.innerclass;

//内部类可以访问外部类的私有属性
public class Outer {
    //属性
    private int id;
    //方法
    public void out(){
        System.out.println("这是外部类的方法");
    }

    //成员内部类
    public class Inner{
        //方法
        public void in(){
            System.out.println("这是内部类的方法");
        }

        public void getId(){
            System.out.println(id);
        }
    }
}

package com.mingmao.javaobjectoriented.programming;

import com.mingmao.javaobjectoriented.programming.innerclass.Outer;

public class Application {
    public static void main(String[] args) {
        //创建内部类对象
        Outer outer=new Outer();
        Outer.Inner inner=outer.new Inner();
        //调用内部类方法
        inner.in();
        inner.getId();
    }
}

静态内部类

package com.mingmao.javaobjectoriented.programming.innerclass;

public class Outer {
    //属性
    private int id;
    //方法
    public void out(){
        System.out.println("这是外部类的方法");
    }

    //静态内部类
    //不能访问外部类的非静态方法和属性
    public static class Inners{
        //方法
        public static void in(){
            System.out.println("这是静态内部类的静态方法");
        }
    }
}

package com.mingmao.javaobjectoriented.programming;

import com.mingmao.javaobjectoriented.programming.innerclass.Outer;

public class Application {
    public static void main(String[] args) {
        //访问静态内部类的静态方法
        Outer.Inners.in();

    }
}

同一java类下的类

package com.mingmao.javaobjectoriented.programming.innerclass;

public class Outer {
    //属性
    private int id;
    //方法
    public void out(){
        System.out.println("这是外部类的方法");
    }
}

//同一java类下的类
//一个java类中只能有一个public类，但可以有多个class
class A{
    public static void main(String[] args) {
        
    }
}

局部内部类

package com.mingmao.javaobjectoriented.programming.innerclass;

//内部类可以访问外部类的私有属性
public class Outer {

    //局部内部类-写在方法里面
    public void method(){
        class Inner{
            
        }
    }
}

匿名内部类

package com.mingmao.javaobjectoriented.programming.innerclass;

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("吃苹果");
    }
}

interface UserService{
    void hello();
}

学习视频

标签：Java06,03,void,System,面向对象,Student,println,public,out
来源： https://www.cnblogs.com/mingmao/p/15243139.html