javaSE(基础四) 面向对象(三)

javaSE(基础四) 面向对象(三)

javabean

Javabean:
泛指一系列的模板类,是一系列的统称
模板类|javabean|实体类|pojo…

Javabean的开发规范:
1.类是公共的
2.至少提供一个空构造,可选择的提供带参构造
3.属性私有化
4.提供公共的访问方式 setter getter

class Dog{
    private String dogName;
    private int age;
//构造器  快捷键: alt+insert->generate->constructor->选中属性|select none->生成
public Dog() {
}
public Dog(String dogName) {
    this.dogName = dogName;
}
public Dog(String dogName, int age) {
    this.dogName = dogName;
    this.age = age;
}
//设置器访问器 alt+insert->generate->setter getter
public String getDogName() {
    return dogName;
}
public void setDogName(String dogName) {
    this.dogName = dogName;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
}

Package 与 import

Package:

​ 包: 相当于系统中的文件夹
​ 作用:
​ 1.管理众多的java资源
​ 2.提供多重命名空间
​ 包信息 : 存在java类的首行
​ 定义规范: 全部小写,每个层级之间使用.分隔
​ 公司域名倒着写.功能名字|模块名字

import:

​ 想要在A类中使用B类,(创建B类的对象,调用B类中的静态内容)
​ 不需要导包的类:
​ 1.同包下的
​ 2.java.lang包下的内容(String,System)
​ 想要使用其他包下的类,非lang包下的内容,需要指明类的位置,需要导包 :
​ 1.使用的时候直接指明类的位置,使用一次需要指明一次,比较麻烦
​ 2.import 导包
​ 指明当前类中使用的某个类型的位置
​ 位置: 类的尚明
​ 语法: import 包名.类名;
​ 3.如果使用了某一个包下的多个类,可以一个一个导入,可以一起导入:
​ 模糊匹配: * 模糊匹配某一个包下的多个类
​ import java.util.*;
​ 优点: 方便
​ 缺点: 降低编译效率,不会降低运行效率
​ 4.静态导入
​ 只导入一个类中的某个静态内容
​ import static

继承

继承: 子承父业

​ extends关键字实现继承
​ 子类 extends 父类

作用:

第一好处：继承的本质在于抽象。类是对对象的抽象， 继承是对某一批类的抽象。

第二好处：为了提高代码的复用性。（事实上，利用组合可以更好的实现代码复用！）子类一旦继承父类,就有权使用父类中的内容

extands的意思是“扩展”。子类是父类的扩展. 可以定义子类中独有的内容

继承是单继承机制,一个子类只能继承一个父类,多实现. 一个父类可以存在多个子类

继承的本质是对某一批类的抽象，从而实现对现实世界 更好的建模。

单继承的优点与缺点:

优点: 简单
缺点: 不便于后期维护

父类与子类别称

父类|超类|基类: 被继承的类
子类|派生类 : 继承父类的类

方法的重写

重写与重载的区别

​ 都是方法的特性

重载:
1.同一个类中的多个方法
2.方法名相同
3.参数列表不同|方法签名不同

重写:
1.不同的类
2.继承|实现
3.方法签名相同

方法的重写: 方法体的重新实现

需求前提:

​ 从父类中继承的功能想要,但是实现方式不想要,定义子类独有的对于这个功能的实现,通过方法的重写实现

注意:
子类对象调用成员的时候,如果子类中有,就就近原则找子类的,子类没有找父类的
当子类中存在方法的重写,子类对象会调用子类中重写的方法,子类没有找父类

不能重写的方法:
1.被private修饰的方法 不能被重写
2.被final修饰的额方法不能被重写
3.被static修饰的方法 不能被重写
并且如果子类中出现于父类静态方法同名的方法,要求也是静态的

检查重写的方式:
1.在行号的位置显示o箭头指向被重写的方法
2.在重写方法的上面添加一个@Override 强制检查此方法是否为一个重写方法,不是报错

重写的三个条件:
1.== 子类重写方法与父类中的被重写方法 方法签名要求完全相等
2.<= 如果子类重写方法与父类中的被重写方法 返回值类型是基本数据类型,要求完全相等,引用数据类型,子类<=父类
3.>= 子类重写方法的权限修饰符>=父类中被重写方法的权限修饰符

权限修饰符

修饰符:
访问权限修饰符 : 修饰成员被访问的权限,不能修饰局部–>成员修饰符
本类中(自己) 同包类(家人) 不同包下的子类(私生子) 不同包下的其他类(陌生人)
private私有的 √
default默认的 √ √
protected受保护的 √ √ √
public公共的 √ √ √ √

注意:
能够修饰类的public,default(默认省略)
在不同包下的子类中,通过继承关系才能使用受保护的成员

//测试
//同包类
public class Test {
    public static void main(String[] args) {
        //同包类下私有的属性无法使用,只能在本类中使用
        ModifierDemo m = new ModifierDemo();
        //System.out.println(m.testPrivate);
        System.out.println(m.testDefault);
        System.out.println(m.testProtected);
        System.out.println(m.testPublic);
    }
}

//SonTest
package com.xxxx.test;
import com.xxxx.modifier03.ModifierDemo;
import org.w3c.dom.ls.LSOutput;
//其他包下的子类
public class SonTest extends ModifierDemo {
    void test() {
        System.out.println(testPublic);
        System.out.println(testProtected);  //通过继承关系使用
    }
    public static void main(String[] args) {
        //通过子类对象使用父类的成员.通过继承关系使用,通过父类对象使用父类的成员,直接访问父类中成员的权限
        SonTest m = new SonTest();
        System.out.println(m.testPublic);
        System.out.println(m.testProtected);
    }
}

package com.xxxx.test;
import com.xxxx.modifier03.ModifierDemo;
//其他包下的其他类-->最大的权限
public class Test {
    public static void main(String[] args) {
        //只有公共的在哪都能使用
        ModifierDemo m = new ModifierDemo();
       // System.out.println(m.testPrivate);
       // System.out.println(m.testDefault);
       // System.out.println(m.testProtected);
        System.out.println(m.testPublic);
       /* SonTest m2 = new SonTest();
        System.out.println(m2.testPublic);
        System.out.println(m2.testProtected);*/
    }
}

final关键字

final: 最终的
可以修饰局部可以修饰成员
1.被final修饰的变量为常量(标识符的规范)
2.被final修饰的方法不能被重写
3.被final修饰的类不能被继承(太监类)

一个自定义的引用数据类型可以作为 一个类的成员类型

 //常量
        //A++;
        //S中存放的对象的地址,指向新的对象的地址,修改的常量的值->不可以
        //S = new Student();
        //没有修改S存放的地址值,修改这个地址内存空间中的成员变量,但是没有修改常量S的值->可以
        S.age++;

super关键字

super 关键字 this 之间的区别:
this关键字用来指代当前对象(new)
构造器首行调用奔雷中的其他构造器 this(参数)
区分同名变量问题 局部与成员

super
指代父类对象

1)在子类构造器的首行通过super(参数)调用父类的构造器
2)区分同名问题
如果子类与父类存在同名情况(成员),在子类中默认就近原则找子类的,如果想要找父类中的同名成员,使用super.调用
如果子类中存在局部与成员同名情况,默认找局部,想要指代成员通过this.调用
如果没有同名问题,this.和super.都可以省略

​ 如果子类构造器中没有显示调用父类的指定构造器,默认调用父类空构造super()
​ 在一个构造器的首行,this()与super()不能同时存在
​ 当存在子父类继承关系下,创建子类对象–>先父类后子类
​ this和super不能使用在static环境中

同名问题: 子类的成员变量age 与 父类的成员变量age同名时,调用默认就近原则

Object超类

Object 老祖宗类
是所有类的父类
java中的所有类都会直接或者间接的继承自Object

Object类中定义的成员,只要子类有权限访问都能使用

Object中的重点常用方法:

equals

​ 比较两个对象是否相等
​ 认为: 比较引用数据类型的对象数据的时候,不应该比较对象地址,应该 比较对象内容(成员变量的值)–>重写equals方法,想怎么比较就怎么写
​ ==比较对象的地址值
​ Object类中的equals方法 ,也是默认比较对象地址

      public boolean equals(Object obj) {
                return (this == obj);
            }

toString()

1)可以将对象以字符串的形式返回
2)当打印一个对象的引用时候,默认打印的是当前对象调用了toString()的返回值

3)当打印一个对象的引用时候,想要得到一个对象的基本信息|成员变量的值–>可以在子类中重写toString,让它打印成员变量非地址
4)子类中不重写打印对象地址,子类重写,想打印就写什么

Javabean的规范:
5.重写toString

public class ObjectDemo {
    public static void main(String[] args) {
        User u = new User("zhangsan","1233");
        User u2 = new User("lisi","4567");
        User u3 = new User("lisi","4567");
        System.out.println(u2);
        System.out.println(u3);
        //比较对象地址
        System.out.println(u2==u3);
        System.out.println(u2.equals(u3));
    }
}
class User{
    private String name;
    private String pwd;
    public User() {
    }
    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }
    //重写方法
    /*@Override
    public String toString() {
        return name+"-->"+pwd;
    }*/
    @Override
    public boolean equals(Object obj) {  //Object obj = u3;
        //增强程序健壮性  先过滤一下如果地址相等,就是一个对象,不需要比较内容
        if(this==obj){
            return true;
        }
        //先把obj从Object类型强转为User类型,因为想要调用 user的成员变量name
        User other = (User)obj;  //other就是参数对象  User other = u3;
        //如果用户名相等比较用户密码,如果用户名不相等,直接返回false
        if(this.name.equals(other.name) ){
            return this.pwd.equals(other.pwd);
        }
        return false;
    }
}