【JAVA语言学习】Java面向对象Ⅲ

文章目录

• 面向对象的三大特征
• • 封装
  • 继承
  • 多态
• final关键字
• 抽象类

面向对象的三大特征

继承,封装,多态

封装

​ 封装是将类的某些信息隐藏在类的内部,不允许被外接程序直接访问,而是通过该类提供的方法来实现,调用和访问

package com.cxy.javaClass.hw.day4_homework;
public class Person {
    String name,sex;
    int age;
    public String getName() {
        return name;
    }
	public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

​ 打包好的类,可以通过实例化 new 一个新对象,然后通过对象.方法来实现访问,即使类中的属性是static属性,也可以通过相对性方法来获取,

​ 比如:getSex(),getName()…

​ 可以实现对隐藏的信息的操作和访问.

//封装的好处
1.隐藏类的实现细节
2.只能通过规定的方法访问
3.方便加入控制语句
4.方便实现修改

this关键字

​ 在封装类的时候,往往会遇到一些构造方法中的局部变量和成员变量的名字相同,容以发生混乱,导致程序错误,所以引入this

this代表自身的对象,

​ 使用 this.属性 ,就是在类中模拟,在实例化时候,谁来调方法,这个类就是谁.

this必须在非静态方法中

类{
static String name;
public void setName(String name) {
        this.name = name;
    }
}
类 one = new 类;
//避免了 name和name的冲突

继承

​ 继承是面向对象的重要特征,所谓继承,就是子类拥有父类的方法,属性,提高了代码的可扩展性.

​ 满足 is - a 结构的类可以使用继承,比如: 节肢动物 —>甲壳昆虫

​ 或者人类—>男人

​ JAVA中使用extends表示继承关系,新的类拥有父类(基类)的所有非私有属性和方法,不支持多继承.

​ 继承提高了代码可重用性和可扩展性

//父类:
package com.cxy.javaClass.day5;
public class Father {
    static String name,sex;
    static int age;
    public Father(String name, String sex, int age) {
        super();
        System.out.println("父类构造方法");
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public void run(){
        System.out.println(this.name+" run");
    }
}

//子类
package com.cxy.javaClass.day5;
public class Son extends Father{
    public Son(String name, String sex, int age) {
        super(name, sex, age);
        System.out.println("子类构造方法");
    }
}

//测试类
package com.cxy.javaClass.day5;

public class MainCycle {
    public static void main(String[] args) {
        Son s1 = new Son("jack","男",18);
        s1.run();
    }
}

>>父类构造方法
>>子类构造方法
>>jack run

Process finished with exit code 0

上述运行结果表明了:

1.在调用字类的构造方法时,会先调用父类的构造方法,父类之前是object类.

2.当一个类没有继承任何类时,默认继承object类

3.继承的传递性:a–>b b–>c 那c有a的方法和属性

super关键字

​ 1.super类似于this,super在这里代表的时父类对象,

​ 2.子类的构造方法总是先调用父类的构造方法,使用super可以表明使用你弗雷德哪一个构造方法,如果没有显示的调用super(),那么默认调用无参构造方法,

​ 3.一般写在构造方法的第一行

//父类中的构造方法
public Father(String name, String sex, int age) {
        super();
        System.out.println("父类构造方法");
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
//子类中的构造方法
public Son(String name, String sex, int age) {
        super(name, sex, age);
        System.out.println("子类构造方法");
    }

重写(Override)

在子类的部分需求父类无法满足时,需要进行方法的重写,

1.同名方法
2.与父类的方法结构相同
3.返回值相同
4.权限相同
5.构造方法不能重写
6.使用@Override标签

@Override标签

java注解,java提前设置好的标签,运行时会进行解析检测,

使用标签表明此方法是由父类中的方法重写来的,重写中,super可以不写在方法的第一行.

package com.cxy.javaClass.day5;
public class Son extends Father{
    public Son(String name, String sex, int age) {
        super(name, sex, age);
        System.out.println("子类构造方法");
    }
    //重写的标签@Override,说明方法再重写
    @Override
    public void run() {
        System.out.println(this.name+" run 现在 快");
        super.run();
    }
}

关联与依赖

1.关联关系(has - a)
表示两个类有关联,类a有…个类b --一对多
a 有 1一个b --一对一

2.依赖关系(use - a)
指的是一个类用到了另一个类,在某个方法中类b被当作参数,作为局部变量,当程序执行完毕以后,就会被释放掉,
具有 (偶然性,临时性)

//武器类    
package com.cxy.javaClass.day5.yilai;
public class Whitex {
    public String fu(){
        return "欧拉欧拉欧拉欧拉~~";
    }
}
//人物类
package com.cxy.javaClass.day5.yilai;

public class Jojo {
    String name;
    int age;
    public void use(Whitex fu){
        String fu1 = fu.fu();
        System.out.println(fu1);
    }
}
//测试类
package com.cxy.javaClass.day5.yilai;

public class Test {
    public static void main(String[] args) {
        Jojo j1 = new Jojo();
        Whitex w1 = new Whitex();
        j1.use(w1);
    }
}

>>欧拉欧拉欧拉欧拉~~

Process finished with exit code 0
//这就是依赖关系

//班级类
public class Classes{
    private Student cla;//班级
}
//学生类
public  class Student{
    //属性
}
//这就是关联关系

多态

多态是指一种事物在不同时刻的表现状态不同

​ 多态存在需要三个条件

1.要有继承(前提条件)
2.要有重写(前提条件)
3.父类引用指向子类对象

package com.cxy.javaClass.hw.day5_homework.three;
public abstract class CanCry {
    public abstract void cry();
}

package com.cxy.javaClass.hw.day5_homework.three;
public class Cat extends CanCry{
    @Override
    public void cry() {
        System.out.println("我是猫,我的叫声是喵喵喵");
    }
}

package com.cxy.javaClass.hw.day5_homework.three;
public class Dog extends CanCry{
    @Override
    public void cry() {
        System.out.println("我是狗，我的叫声是汪汪汪");
    }
}

package com.cxy.javaClass.hw.day5_homework.three;
public class Test {
    public static void main(String[] args) {
        CanCry dog = new Dog();
        CanCry cat = new Cat();
        Test test = new Test();
        test.makeCry(dog);
        test.makeCry(cat);
    }
    void makeCry(CanCry c){
        if(c instanceof CanCry){
            c.cry();
        }
    }
}

在上面的例子中,测试类方法中使用了多态声明:

	CanCry dog = new Dog();

所以当 makeCry(CanCry c)方法被调用的时候,只要是CanCry类的都可以使用cry,

运行结果为:>>>我是狗，我的叫声是汪汪汪

多态对成员方法,静态方法,成员变量的调用

//多态对成员方法的调用
class Father{
    void eat(){
       System.out.println("父亲吃");
    }
}
class Son extends Father{
    void eat(){
        System.out.println("儿子吃");
    }
}
//测试类
class Test{
    Father s1 = new Son();
    s1.eat()  //这个方法父类和子类都有
}
>>> 儿子吃  //所以在调用成员方法的时候,编译看左边,运行看右边
    
//静态方法
class Father{
   static  void eat(){
       System.out.println("父亲吃");
    }
}
class Son extends Father{
  static  void eat(){
        System.out.println("儿子吃");
    }
}
//测试类
class Test{
    Father s1 = new Son();
    s1.eat()  //这个方法父类和子类都有
}
>>> 父亲吃 //对静态方法来说,编译和运行都看左边
//成员变量
class Father{
   int a = 2;
}
class Son extends Father{
 int a = 3;
}
//测试类
class Test{
    Father s1 = new Son();
    System.out.println(s1.a);  //这个属性父类和子类都有
}
>>> 2  //编译和运行都看左边

转型问题

class Animal{
   void eat(){ }
}
class Cat extends Animal{
   void fuc() {
		System.out.println("fuc");
	}
}      

上面例子里

Animal x=new Cat() ====>向上转型 对于这种方法x.eat 可以运行 x.fuc()不能运行,只能调用父类的方法,不能使用子类的,但是提高了程序的可扩展性

如果想使用子类的方法,可以使用向下转型

Cat m = (Cat)x; 此时的m可以调用 m.fuc() 可以运行

final关键字

可以修饰属性, 方法 ,类

被final修饰过的那些东西,后期都不能修改,方法不能被重写,类不可被继承

package com.cxy.javaClass.day5.finalJava;
public class Father {
    final int student_num = 130001;
    public final void hit(int student_num){
        //this.student_num = student_num;//出错
        System.out.println(student_num);
    }
}

package com.cxy.javaClass.day5.finalJava;
public class GrandSon{

}

package com.cxy.javaClass.day5.finalJava;
public final class Son extends Father{
    int age;
    //public void hit(int stu){System.out.println(stu);}//不可重写
    public void hit2(int stu){
        System.out.println(stu);
    }
}

抽象类

抽象类就是这个类中没有足够的信息描述这个对象,也就是没写完的类

有抽象方法的类一定是抽象类,抽象类却不一定有抽象方法

使用关键字abstract.

抽象类不能被实例化

子类必须重写抽象方法,或者子类也是抽象类

package com.cxy.javaClass.day5.polymorphic;
public abstract class Person {
    String name,sex;
    int age = 18;
    public abstract void eat();
    public static void fu(){
        System.out.println("人 fu");
    }
}

package com.cxy.javaClass.day5.polymorphic;
public class Acther extends Person{
    String name,sex;
    int age;

    @Override
    public void eat() {
        System.out.println("acher eat");
    }
    public static void fu(){
        System.out.println("acher fufu");
    }
    public void oula(){
        System.out.println("欧拉欧拉欧拉~");
    }
}

本文地址：https://blog.csdn.net/qq_44126342/article/details/109273421