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 = "王思聪";//重写方法@Overridepublic 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) {//toStringPerson 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方法,实现返回的不是地址而是成员变量的值@Overridepublic String toString() {return name+","+age;}}

（8）equals方法

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

//实例代码-equals方法
public class Class001_Object01{public static void main(String[] args) {//toStringPerson p = new Person();p.name = "zhangsan";p.age = 19;Person p2 = new Person(); //0x001p2.name = "zhangsan";p2.age = 19;//比较两个person对象,不想比较地址,想要比较姓名System.out.println(p.equals(p2)); //0x001System.out.println(p==p2);}
}class Person{public String name;public int age;public Person(){}public void show(){System.out.println(name+"-->"+age);}//比较两个person对象,不想比较地址,想要比较人的姓名,姓名相等就像等@Overridepublic 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方法