自学java第七天：面向对象编程（第二部分）

于 2023-01-13 17:08:09 发布
阅读量51 收藏
点赞数
分类专栏： 自学java每日记录点滴 文章标签： java 开发语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50905233/article/details/128673580
版权

  1. 方法的重写

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

        //方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();//A

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

    }
}
//继承
public class A extends B{
    public static void test(){
        System.out.println("A=>test（）");
    }
}
//重写都是方法的重写，和属性无关
public class B {
    public static void test(){
        System.out.println("B=>test（）");
    }
}
public class Application {
    //静态的方法和非静态的方法区别很大！
    //静态方法： 方法的调用只和左边定义的数据类型有关
    //非静态的：重写
    public static void main(String[] args) {


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

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

    }
}
//继承
public class A extends B{
    //Override  重写
    @Override//注解：有功能的注释
    public void test() {
        System.out.println("A=>test（）");
    }
}
//重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B=>test（）");
    }
}

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

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大：public>Protected>Default>private

4.抛出的异常：范围可以被缩小，但不能扩大；ClassNotFoundException--》Exception(大)

重写，子类的方法必须和父类一致，方法体不同！

为什么需要重写：

1.父类的功能，子类不一定需要，或者不一定满足

2.快捷键重写Alt Insert:Override

  1. 多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件：1.有继承关系

2.子类重写父类方法

3.父类引用指向子类对象

注意:多态是方法的多态，属性没有多态性。

instanceof

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();
        ((Student) s2).eat();
        s1.eat();
    }
public class Person {
    public void run() {
        System.out.println("run");

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

多态注意事项：

1.多态是方法的多态，属性没有多态。

2.父类和子类，有联系 类型转换异常！ClassCastException!

3.存在的条件：继承关系，方法需要重写,父类引用指向子类对象！father f1 = new Son();

不能被重写的：static方法，属于类，不属于实例

final常量

private方法

instanceof（类型转换）引用类型，判断一个对象是什么类型~

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

        //object>String
        //object>Person>Teacher
        //object>Person>Student
        Object object = new Student();

        //System.out.println(X instanceof Y);//能不能编译通过！
        //X和Y之间是否存在父子关系

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

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

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





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

    }
}
public class Student extends Person{


}
public class Teacher extends Person {
}
public class Application {
    public static void main(String[] args) {

        //类型之间的转换： 父 子
        //高                  低
        Person obj = new Student();

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

        //子类转换成父类，可能丢失自己本来的一些方法
        Student student = new Student();
        student.go();
        Person person = student;


    }





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

    }
}

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


}
public class Teacher extends Person {
}

  1. static

//static
public class Student {
    private  static int age;//静态的变量  多线程
    private  double score;//非静态的变量

    public void run() {

    }

    public static void go() {

    }

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);

        s1.run();
        Student.go();

    }
}
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();
    }
}
//静态导入包
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);
    }
}

  1. 抽象类

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。

抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

//abstract 抽象类；类，  单继承
//接口是可以多继承的
public  abstract class Action {
    //约束，，别人帮我们实现
    //abstract， 抽象方法，只有方法名字，没有方法实现！
    public abstract void doSomething();

    //1.不能new这个抽象类，只能通过子类来实现它：约束！
    //2.抽象方法必须在抽象类中
    //3.抽象类中可以写普通方法
    //抽象的抽象：约束
}
//抽象类的所有方法，继承了他的子类，都必须要实现他的方法
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

  1. 接口

普通类:只有具体实现

抽象类:具体实现和规范(抽象方法)都有!

接口:只有规范!自己无法写方法~专业的约束！约束和实现分离：面向接口编程~

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能…..”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。

接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是class,声明接口的关键字是interface

//抽象类：extends~
//类 可以实现接口implements接口
//实现了接口的类，都需要重写接口中的方法
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @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() {

    }
}
//定义的关键字 interface,接口都需要实现类
public interface UserService {
    //接口中的所有定义都是抽象的
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
public interface TimeService {
    void timer();
}

接口的作用

1.约束

2.定义一些方法，让不同的人实现

3.public abstract

4.public static final

5.接口不能被实例化，接口中没有构造方法

6.implements可以实现多个接口

7.必须要重写接口中的方法

  1. 内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

  1. 成员内部类

  1. 静态内部类

  1. 局部内部类

d.匿名内部类

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public  void getID(){
            System.out.println(id);

        }
    }
    //局部内部类
    public void method(){
        class Inner2{
            public void in(){
                
            }
        }

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

    }
}
public class Application {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();

        //通过这个外部类来实例化内部类

        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}
zxinlia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值