【JAVA语言学习】Java面向对象Ⅲ
文章目录
面向对象的三大特征
继承,封装,多态
封装
封装是将类的某些信息隐藏在类的内部,不允许被外接程序直接访问,而是通过该类提供的方法来实现,调用和访问
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
上一篇： File类 (Java)