Java学习笔记7-面向对象(续)

        一个国家有很多省,省又分为市,市里面又分为县或者镇,省与省之间又有很多不同的特色。之所以这样去分就是因为好区分,便于管理，这种原理和Java里面的包（package）很相似。

1.package（包）与import（导入）

     (1)包机制：文件夹

          之所以有package，是为了解决类之间的重名问题，为了便于管理合适的类位于合适的包！

位置：通常是类的第一句

包名：域名倒着写，再加上模块名，并与内部管理类。（com.xxx.xxx）

 （2）import

        如果不适用import，我们如果用到其他包的类时，只能 这么写：java.util.Date，代码量太大，不利于编写和维 护。通过import可以导入其他包下面的类，从而可以在 本类中直接通过类名来调用。

• 位置：类的上面，包信息的下面
• 导包： 指明要使用的类的位置----import 包名.类名;
• 模糊匹配*：模糊匹配当前包下的所有类 import java.util.*;（这样做影响编译效率不会影响运行效率
• ）
• 静态导入:只能导入某个类中的静态内容(了解)

注：java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。

2.private私有的（封装的一种体现）

        封装的具体体现：隐藏内部的实现细节,属性私有化配合公共的访问方式，方法、类都是封装的体现。 

        封住的含义：隐藏内部的实现细节,对外提供公共的访问方式 

        封装的优点：1.提高了代码安全性 2.提高了代码的复用性

 private（私有的）：成员修饰符，不能修饰局部，被private修饰的成员只能在本类中使用。

提供公共的访问方式: 公共的成员方法(非静态) 、设置器 setter、访问器 getter

 私有的属性，配合公共的访问方式提供成员的安全性。

 注：私有是封装,封装不一定是私有

        未来所定义的javabean类,所有的属性都应私有化,并提供公共的访问方式

//实例代码-private的修饰与访问方式
public class Class002_User {
    public static void main(String[] args) {
        //创建用户对象
        User user = new User();
        user.setId(101);
        user.setUsername("zhangsan");
        user.setPassword("lisi");
        //调用方法查看成员变量是否赋值成功
        user.show();
    }
}
//定义用户类
class User{
    //属性私有化
    private int id;
    private String username;
    private String password;

    //构造器（无参）
    public User(){

    }
    //构造器（有参数）
    public User(int id,String username,String password){
        this.username = username;
        this.id = id;
        this.password = password;
    }

    //公共的设置器与访问器
    public void setId(int id){
        this.id = id;
    }
    public void setUsername(String username){
        this.username = username;
    }
    public void setPassword(String password){
        this.password = password;
    }
    //公共的访问器
    public int getId(){
        return id;
    }
    public String getUsername(){
        return username;
    }
    public String getPassword(){
        return password;
    }

    //功能
    public void show(){
        System.out.println(id+"-->"+username+"-->"+password);
    }
}

3.继承

（1）什么是继承？为什么要使用继承？继承的作用是什么？

继承的本质是就是继承，子承父业（可以得到父类的全部属性和方法 (除了父类的构造方法)）。

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

为了提高代码的复用性。

作用：子类一旦被继承父类，就有权使用父类中的内容

子类中可以扩展自己独有的内容 （延续+扩展）

格式：子类 extends 父类

注：一个子类只能存在一个直接父类， 一个父类可以存在多个子类

//实例代码-继承
public class Class001_Extends {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        //子类中成员没有的去父类中找
        teacher.name = "马云";
        teacher.age = 30;
        teacher.subject = "英语";
        teacher.teach();
        teacher.sleep();
        teacher.show();
    }
}

//父类
class Person{
    public String  name;
    public int age;
    public void sleep(){
        System.out.println("休息");
    }
}

//教师类（子类）
class Teacher extends Person{
    public String subject; //教授学科
    public Teacher(){}
    public void teach(){
        System.out.println("教书育人");
    }

    public void show(){
        System.out.println(name+"-->"+age+"-->"+subject);
    }
}

//学生类（子类）
class Student extends Person{
    public int id; //学号
    public Student(){}
    public void study(){
        System.out.println("学习...");
    }

}

（2）super关键字

        super 是直接父类对象的引用。可以通过super 来访问父类中被子类覆盖的方法或属性。

        在子父类关系下,创建子类对象 : 先父类后子类 (在子类内存空间中存储父类对象,可以通过super在子类中使用父类对象)

super需要在子类中使用

（1）在子类的构造器首行通过super调用父类的执行构造器

• super(参数列表)
• 默认在子类构造器的首行会调用父类的空构造 super()
• 在子类构造器的首行不能同时显示存在this()与super(),因为都需要定义在首行第一个条语句

 （2） super区分子父类中同名成员问题  

如果子父类中出现同名的成员,子类中使用这个成员,默认就近原则

如果想要调用父类同名成员,通过super.调用父类成员 (super指代子类内存中的父类对象)

this用来区分同类中局部与成员之间同名问题

• super默认就近原则找局部变量
• 可以通过this.调用本类成员
• 可以通过super.调用父类成员

父类与子类中局部变量与成员变量如果不存在同名问题,指代父类成员可以省略super.

同类中局部变量与成员变量如果不存在同名问题,指代子类成员可以省略this.

//实例代码-super关键字
public class Class002_Super {
    public static void main(String[] args) {
        Apple f = new Apple("红富士");
        f.show();
    }
}
//父类
class Fruit{
    public String type;
    public String color;
    public String haha = "父类哈哈";
    //父类无参数构造器
    public Fruit(){
        System.out.println("父类构造器");
    }
    //父类有参数构造器
    public Fruit(String type){
        System.out.println("父类带参造器");
        this.type = type;
    }
}
//子类
class Apple extends Fruit{
    public String haha = "子类哈哈";
    //子类构造器无参数
    public Apple(){
        //super();没有参数时默认会有super关键字
        System.out.println("子类构造器");
    }
    //子类构造器有参数
    public Apple(String type){
        super(type);//直接调用父类相同参数构造器直接使用
        System.out.println("子类带参构造");
    }
    public void show(){
        System.out.println(super.type+"-->"+color);
        //局部变量
        String haha = "局部哈哈";
        System.out.println(haha); //局部
        System.out.println(this.haha); //本类成员this指代当前对象
        System.out.println(super.haha); //父类成员super指代父类对象
    }
}

（3）方法的重写（override）

        当子类中继承父类的方法，子类对父类某个功能满意,功能实现不满意,可以在子类中对这个功能进行重写。

使用特点: 子类引用会调用子类中重写的方法,子类没有找父类,子类有找子类,会对父类中的方法进行屏蔽。

重写的前提：1.不同的两个类

                      2.继承|实现关系

                      3.方法签名相同

如何检查一个方法是否是重写方法:

         1.在行号的后面显示,点击会跳转到对应被重写的方法位置

         2.@Override 强制检查一个方法是否为重写方法

//实例代码-重写
public class Class001_Override {
    public static void main(String[] args) {
        SiCong cong = new SiCong();
        cong.words();
    }
}
class JianLin{
    public String name = "王健林";

    public JianLin words(){
        System.out.println("先定一个小目标,挣它一个亿...");
        return null;
    }
}
class SiCong extends JianLin{
    public String name = "王思聪";
    //重写方法
    @Override
    public JianLin words(){
        System.out.println("我不在乎我的朋友有钱没钱,反正没我有钱...");
        return null;
    }

重写时子类与父类方法要求：

== 方法签名
<= 返回值类型 :
    基本数据类型 : 完全相等
    引用数据类型 : 子类中重写方法的返回值类型 <= 父类中被重写方法的返回值类型
    没有返回值类型 : 完全相等
>= 权限修饰符 :
    子类中重写方法的权限修饰符 >= 父类中被重写方法的权限修饰符

注：不能被重写的方法:

（1）被private修饰的方法不能被重写

（2）被final修饰的方法不能被重写

（3）被static修饰的方法不能被重写

         子类中如果存在与父类静态方法同名的方法,要求子类中的同名方法也需要被static修饰

（4）访问权限修饰符

        成员的被访问权限,成员修饰符不能修饰局部。

能够修饰的类的 : public , default(省略)

私有的内容能被继承,但是无权使用

受保护的成员 : 1.同包类

                         2.在不同包的子类中,通过继承关系访问

常用的权限修饰符: public privat

（5）final关键字

final关键字 最终的

final可以修饰成员可以修饰局部

        1.被fianl修饰的变量为常量

        2.被final修饰的方法不能被重写

        3.被final修饰的类不能被继承-->太监类

（6）Object类

        Object类是所有Java类的根基类（可以看成父类），Java中的类都会直接或者间接的继承自Object类。如果一个类没有显示的继承自其他类，默认继承自Object类。

//实例代码
public class Person {
...
}

等价于：

//实例代码
public class Person extends Object {
...
}

（7）toString方法

        Object类中定义有 public String toString() 方法，其返回值是 String 类型，用来描述当前对象的有关信息。

        toString():把对象数据转为字符串的变现形式。

        如果直接打印一个引用，默认打印的是这个调用toString方法的返回值

        需求：以一个字符串展示一个对象，想要了解到对象的一些基本的信息（成员变量的值）

注：Object类中的toString方法的实现，默认以对象的地址展示。子类中重写toString方法，实现返回对象的成员变量的值非地址值。

//实例代码——toString方法
public class Class001_Object01{
    public static void main(String[] args) {
        //toString
        Person p = new Person();
        p.name = "zhangsan";
        p.age = 19;
        System.out.println(p.toString());
        System.out.println(p);
        

    }
}
//定义一个类
class Person{
    public String name;
    public int age;
    public Person(){}
    public void show(){
        System.out.println(name+"-->"+age);
    }
    //重写toString方法,实现返回的不是地址而是成员变量的值
    @Override
    public String toString() {
        return name+","+age;
    }

}

（8）equals方法

Object类中定义有：equals比较两个对象是否想等（默认比较对象的地址），如果不想比较对象的地址，想要比较所有的成员变量，可以在之类中重写equals方法。

//实例代码-equals方法
public class Class001_Object01{
    public static void main(String[] args) {
        //toString
        Person p = new Person();
        p.name = "zhangsan";
        p.age = 19;
        Person p2 = new Person(); //0x001
        p2.name = "zhangsan";
        p2.age = 19;

        //比较两个person对象,不想比较地址,想要比较姓名
        System.out.println(p.equals(p2)); //0x001
        System.out.println(p==p2);
    }
}

class Person{
    public String name;
    public int age;

    public Person(){}


    public void show(){
        System.out.println(name+"-->"+age);
    }

    //比较两个person对象,不想比较地址,想要比较人的姓名,姓名相等就像等
    @Override
    public boolean equals(Object obj) {  //Object obj = 0x001;
        //增强程序健壮性
        if(this == obj){
            return true;
        }

        //判断obj指向的是一个Person对象么??
        if(obj instanceof Person){
            //如果是就把obj从Object转为Person类型
            Person p = (Person)obj;  //Person p = 0x001;
            //可以调用Person类中的成员
            String name2 = p.name;
            String name1 = this.name;
            return name1.equals(name2);
        }
      return false;
    }
}

注：equals与==之间的区别

        ==：基本数据类型比较数据值

        equals:引用数据类型比较对象的地址值

4.JavaBean(模板类)定义规范

        1.类是公共的

        2.至少提供一个空构造

        3.属性私有化

        4.提供一堆公共的访问方式

        5.重写toString与equals方法