Java---面向对象02

本文主要是介绍Java---面向对象02，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1.方法的重写

需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符 : 范围可以扩大但不能缩小
   (大)public–>Protected–>Default–>private(小)
4. 抛出的异常 : 范围，可以被缩小，但不能扩大；
   ClassNotFoundException–>Exception(大)

• 重写，子类的方法和父类必须要一致；方法体不同
• 为什么要重写:
  1.父类的功能，子类不一定需要，或者不一定满足
  Alt + Insert ; override; (重写)

package OPP.Demo08;

//重写都是方法的重写，和属性无关
public class B {

    public void test(){
        System.out.println("B=>test()");
    }
}

package OPP.Demo08;

//继承
public class A extends B{

    @Override  //重写   注解:有功能的注释
    public void test() {
        System.out.println("A=>test()");
    }
}

package OPP.Demo08;
import OPP.Demo08.A;
import OPP.Demo08.B;

public class Application {

    //静态方法和非静态方法的区别很大
    //静态方法: 方法的调用只和左边，定义的数据类型
    //非静态: 重写
    public static void main(String[] args) {

        A a =new A();
        a.test();    //A

        //父类的引用指向了子类
        B b=new A();  //子类重写了父类的方法
        b.test();    //B
    }
}

结果展示:

2.多态

• 动态编译 : 类型:可扩展性

• 即同一方法可以根据发送对象的不同而采取多种不同的行为方式

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

• 多态存在的条件
  1.有继承关系
  2.子类重写父类方法
  3.父类引用指向子类对象

• 注意 :
  1.多态是方法的多态，属性没有多态性
  2.父类和子类，有联系 //类型转换异常! (ClassCastException!)
  3.存在条件: 继承关系，方法需要重写，父类引用指向子类对象

• 不能被重写的方法
  1.static 方法，属于类，它不属于实例
  2.final 常量；
  3 private 方法；

代码示例

package OPP.Demo09;

public class Person {

    public void run(){
        System.out.println("son");
    }
}

package OPP.Demo09;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}

package OPP.Demo09;
import OPP.Demo09.Person;
import OPP.Demo09.Student;

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

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        ((Student) s2).eat();   //子类重写了父类的方法，执行子类的方法
        s1.run();
    }
}

测试结果:

3.instanceof与类型转换

instanceof(类型转换)
引用类型，判断一个对象是什么类型

类型转换

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型
3. 把父类转换为子类，向下转型； 强制转换
4. 方便方法的调用，减少重复的代码。
   代码示例:

package OPP.Demo09;

public class Person {}

package OPP.Demo09;

public class Teacher {}

package OPP.Demo09;

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

package OPP.Demo09;
import OPP.Demo09.Person;
import OPP.Demo09.Student;

public class Application {
    public static void main(String[] args) {

        //类型之间的转化: 父    子

        //高                  低
        Person obj=new Student();

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        Student student=(Student)obj;
        student.go();

        System.out.println("=====================================");
        //Object->String
        //Object->Person->Teacher
        //Object->Person->Student
        Object object=new Student();

        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);
        //System.out.println(X instanceof Y);   //能不能编译通过要看是否有继承关系
   }
}

测试结果:

4.static

package OPP.Demo10;

public class Student {

    private static int age;   //静态变量
    private double score;    //非静态变量

    public void run(){

    }
    public static void go(){
        System.out.println("go");
    }

    public static void main(String[] args) {
        go();
    }
}

测试结果:

package OPP.Demo10;

public class Person {
    //2.赋初值
    {
        System.out.println("匿名代码块");
    }
    //1.只执行一次
    static{
        System.out.println("静态代码块");
    }
    //3.
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1=new Person();
        System.out.println("=================");
        Person person2=new Person();
    }
}

测试结果:

package OPP.Demo10;
//静态导入包
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);
    }
}

测试结果:

5.抽象类

• abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，该方法就是抽象方法；如果修饰类，该类就是抽象类
• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类
• 抽象类，不能用new关键字来创建对象，它是用来让子类继承的
• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

代码注解:

package OPP.Demo11;

//abstract 抽象类
public abstract class Action {

    //约束，有人帮我们实现
    //abstract，抽象方法，只有方法名字，没有方法的实现
    public abstract void dosomething();
}
/*
1.不能new这个抽象类，只能靠子类去实现它；约束
2.抽象类中可以写普通的方法
3.抽象方法必须在抽象类中
*/

package OPP.Demo11;

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法
public class A extends Action{
    @Override
    public void dosomething() {

    }
}

6.接口

• 普通类:只有具体实现
• 抽象类;具体实现和规范(抽象方法)都有
• 接口: 只有规范。 (约束和实现分离:面向接口编程)
• 接口的本质是契约

接口的作用

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

代码注解:

package OPP.Demo12;

//interface 定义的关键字，接口都需要有实现类
public interface UserService {

    //常量   public static final
    int age=19;

    //接口中所有定义的方法其实都是抽象的 public abstract
    void add(String name);   //增
    void delete(String name);   //删
    void update(String name);   //改
    void query(String name);   //查
}

package OPP.Demo12;

public interface TimeService {
    void time();
}

package OPP.Demo12;

//抽象类: extends
//类 可以实现接口  implements 接口
//多继承，可以利用接口来实现
public class UserServiceImpl implements UserService,TimeService{   //多继承

    @Override
    public void time() {
    }

    @Override
    public void add(String name) {
    }

    @Override
    public void delete(String name) {
    }

    @Override
    public void update(String name) {
    }

    @Override
    public void query(String name) {
    }
}

7.内部类

• 内部类就是在一个类的内部再定义一个类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

一个Java类中可以有多个class类，但只能有一个public class类

代码注解:

package OPP.Demo13;

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 OPP.Demo13;

public class Application {
    public static void main(String[] args) {

        Outer outer = new Outer();

        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

测试结果:

这篇关于Java---面向对象02的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！