面相对象2

面相对象的特性: 继承

目的: 为了提高代码的复用性

类:对对象进行抽象,抽出像的部分

父类: 对一些类进行抽象,抽出像的部分

父类|超类|基类:被继承的类

子类|派生类: 继承父类的类

使用方法: 子类 extends 父类

继承的优点:

1.子类一旦继承父类,可以使用父类中的内容

2.子类是父类的延续+扩展

3.可以提高代码的复用性

单继承继承,一个子类只能继承一个父类,一个父类可以被多个子类继承,可以多实现

单继承的优点:

使用简单

单继承的缺点:

不便于后期维护

*实例

public class ExtendsDemo01 {

public static void main(String[] args) {

Student s=new Student();

s.name="马爸爸";

s.age=30;

s.study();

s.sleep();

Teacher t=new Teacher();

t.name="zhangsan";

t.age=20;

t.teach();

t.sleep();

}

}

//抽取子类的共性定义父类

class Person{

String name;

int age;

//休息

public void sleep(){

System.out.println(name+"边敲代码边休息...");

}

}

//教师类

class Teacher extends Person{

String subject;

public Teacher() {

// TODO Auto-generated constructor stub

}

//教学

public void teach(){

System.out.println(name+"教学..");

}

}

//学生

class Student extends Person{

int time;

public Student() {

}

//学习

public void study(){

System.out.println(name+"学习java..");

}

}

重写:

重写 和 重载的区别

重写:

1)不同的类

2)继承关系

3)方法签名相同

重载:

1)同一个类中,有多个方法

2)方法名相同

3)参数列表不同

重载和重写都是指方法

1 子父类中一旦存在方法的重写,在调用的时候,会调用子类中重写的方法,对父类的方法这个方法进行屏蔽

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

* t1.在这个重写的方法的上面添加一个注解 @Override

* t2.左侧会出现向上的三角形

注意:

1.== 方法签名完全相同

2.<= 返回值类型: 基本数据类型必须相同, 引用数据类型:子类重写方法的返回值类型<=父类中方法的返回值类型

3.>= 权限修饰符: 子类重写方法的权限修饰符>=父类重写方法的权限修饰符

4.被private修饰的方法不能被重写

5.static修饰的方法不能被重写

如果父类中有个同名的静态方法,子类中要定义这个名字的方法,必须也被static修饰

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

* 什么时候定义方法的重写:

当子类需要父类中的某个功能,但是对父类中直接继承过来的功能体实现不满意,可以对父类中的方法进行重写,自定义方法体

public class OverrideDemo01 {

public static void main(String[] args) {

SiCong si=new SiCong();

si.words();

si.haha();

JianLin jian=new JianLin();

jian.words();

}

}

class JianLin{

JianLin words(){

System.out.println("先定一个小目标,赚它一个亿...");

return null;

}

static void haha(){

System.out.println("哈哈哈");

}

}

class SiCong extends JianLin{

//就近原则

@Override

public SiCong words() {

haha();

System.out.println("我不在乎我的朋友有钱没钱,因为都没我有钱...");

return null;

}

}

面相对象的特性: 多态

一种事物的多种形态,多种变现形式

多态的最终体现: 父类引用指向子类对象

多态的前提:

类的继承

接口的实现

多态 父类引用再去调用方法的时候,会调用子类中重写的方法

*注意: 父类引用对于子类新增内容不可见

多态调用时候:

变量:

编译运行看类型|父类|左边

方法:

编译看类型,运行才找对象

多态 如果没有方法的重写没有意义

public class Demo01 {

public static void main(String[] args) {

//Person p=new Person();

//多态

Person s=new Student();

s.test();

System.out.println(s.name);

//s.hehe();

//特点:在检查语法时候,引用s能否调用,要检查s的数据类型Person中是否存在你要调用的内容,如果有可以,没有就报错

}

}

class Person{

String name="999";

void test(){

System.out.println("Person");

}

}

class Student extends Person{

//String name="123";

void test(){

System.out.println("Student");

}

void hehe(){

System.out.println("hahahehe");

}

}

关键字

super关键字 和this之间的区别:

this:指代当前 创建的对象

super:父类对象

使用在构造器的首行,调用父类的构造器 super(参数列表)

如果子类没有显示调用父类构造器,默认调用父类空构造

如果子类构造器中有显示调用父类中的任何构造器,就不会再次默认调用空构造了

this()和super()不能显示同时出现

区分同名问题:同名变量|同名方法

如果不存在子父类同名问题:父类有找父类 , 子类有找子类

如果存在子父类同名问题: 默认找子类,因为就近原则,如果想要找父类同名成员,使用super.进行调用,因为super默认指代父类对象

创建对象的过程: 先父类后子类

先静态后成员

this和super不能和static一起使用

public class SuperDemo04 {

public static void main(String[] args) {

Zi zi=new Zi("haha");

zi.test();

System.out.println(zi);

}

}

class Fu{

String name="张翠山";

public Fu() {

System.out.println("我是父类空构造");

}

public Fu(String name) {

System.out.println("我是父类带参构造");

this.name=name;

}

}

class Zi extends Fu{

String name="张无忌";

public Zi() {

super("lllllll");

System.out.println("我是子类空构造");

}

public Zi(String str) {

//super();

this();

System.out.println("我是子类带参构造");

}

void test(){

String name="张三丰";

//父类对象在子类对象内存空间中,外部无法使用,只能通过子类对象使用

System.out.println(name+"-->"+this.name+"-->"+super.name);

System.out.println(this);

}

}

Object 类

老祖宗类 ,是java中所有类的父类

如果一个类没有显示继承其他类,默认继承自Object

java是单继承机制,如果一个类显示继承了其他类,但是它的父类|父类的父类..可能会继承Object

打印一个对象引用时候,默认调用对象的toString方法,打印对象的地址

不想打印对象地址,想要打印对象的基本信息(成员属性的值)

使用重写toString()实现:可以将对象的内容以字符串的形式展现

equals()和 == 之间的区别

==比较引用数据类型比较的是对象的地址值

equals比较对象内容

public boolean equals(Object obj) {

return (this == obj);

}

默认还是比较对象地址,但是子类可以对其进行重写,使用对象比较内容而非地址

public class ObjectDemo02{

public static void main(String[] args) {

Father father1=new Father();

Father father2=new Father();

System.out.println(father1); //默认调用对象的toString方法

System.out.println(father1.toString()); //默认调用对象的toString方法

//比较对象地址

System.out.println(father1 == father2); //false

System.out.println(father1.equals(father2));

String str1=new String("abc");

String str2=new String("abc");

System.out.println(str1.equals(str2));

}

}

class Father extends Object{

String name="红中";

int age=1;

public String toString() {

return name+"-->"+age;

}

@Override

public boolean equals(Object obj) {

//增强程序健壮性代码

if(this == obj){

return true;

}

//只比较对象的年龄,年龄相同对象就相同

if(obj instanceof Father){

return this.age == ((Father)obj).age;

}

return false;

}

}

class Son extends Father{}