文章目录

面向对象的三大特征
- 封装
- - this关键字
- 继承
- - super关键字
  - 重写(Override)
  - - @Override标签
  - 关联与依赖
- 多态
- - 多态对成员方法,静态方法,成员变量的调用
  - 转型问题
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 runProcess 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,说明方法再重写@Overridepublic 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{@Overridepublic void cry() {System.out.println("我是猫,我的叫声是喵喵喵");}
}package com.cxy.javaClass.hw.day5_homework.three;
public class Dog extends CanCry{@Overridepublic 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;@Overridepublic void eat() {System.out.println("acher eat");}public static void fu(){System.out.println("acher fufu");}public void oula(){System.out.println("欧拉欧拉欧拉~");}
}

【JAVA语言学习】Java面向对象Ⅲ相关推荐

Java 基础学习-Java语言概述
Java 基础学习第一章 Java语言概述回顾java基础知识,进行整理记录. 文章目录 Java 基础学习前言一. Java语言发展史(了解) 二.Java语言跨平台原理(理解) 三.JRE ...
计算机二级为什么靠Java的少,计算机二级考试：Java语言学习六大要点
计算机二级考试:Java语言学习六大要点一.掌握静态方法和属性静态方法和属性用于描述某一类对象群体的特征,而不是单个对象的特征.Java中大量应用了静态方法和属性,这是一个通常的技巧.但是这种技巧 ...
Java语言学习思维导图
Java语言学习思维导图
Java进阶学习-7 面向对象程序设计原则
title: Java进阶学习-7 面向对象程序设计原则 date: 2020-02-02 18:02:27 tags: 以一个城堡游戏为例子谈面向对象程序设计原则 Game.java package ...
什么是Java语言？java语言简介
Java是由Sun Microsystems公司于1995年5月推出的Java程序设计语言(以下简称Java语言)和Java平台的总称.用Java实现的HotJava浏览器(支持Java applet ...
1,Java语言基础-Java语言概述和必要计算机知识
Java语言基础 Java语言概述 1,Java语言发展史 Java语言本质 Java是面向对象的高级语言,它是由c和c++发展而来. Java发展语言历史概述 Java 是由 James Gosli ...
2,Java语言基础-Java语言基本程序设计知识
Java语言基础 Java语言基本程序设计知识 1,JavaAPI概述 1.1,什么是API API是指应用程序接口( Application Program Interface, API),故名思意 ...
JAVA语言规范 JAVA SE 8 - 类型、值和变量
JAVA语言规范 JAVA SE 8 - 类型.值和变量类型和值的种类简单类型和值整数类型和值整数操作浮点数类型.格式和值浮点数操作 boolean类型和布尔值引用类型和值对象 Obj ...
java多线程学习-java.util.concurrent详解
http://janeky.iteye.com/category/124727 java多线程学习-java.util.concurrent详解(一) Latch/Barrier 博客分类: java ...
java语言语法--- Java标识符（标识符命名规则）、Java关键字、Java变量(变量的声明、赋值、使用)和常量（字符常量、字面常量）（包括Java字节码文件反汇编命令javap）
java语言语法- Java标识符.Java关键字.Java变量和常量(包括Java字节码文件反汇编命令javap) 1.标识符 (1)读音:biao zhi fu (2)什么是标识符? (摘自百度百 ...

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