活动地址:[CSDN21天学习挑战赛](https://marketing.csdn.net/p/bdabfb52c5d56532133df2adc1a728fd)
前言
【回顾上节】
类的方法
方法是类和对象动态行为特征的抽象。
java对象的创建和使用:
- 必须使用 new 关键字创建对象。
Person person= new Person ();
- 使用对象(引用) . 成员变量来引用对象的成员变量。
person.age
- 使用对象(引用) . 方法(参数列表)来调用对象的方法。
setAge(23)
类中就是://静态的数据 //动态的行为
JAVA程序运行的内存分析
栈 stack:
1. 每个线程私有,不能实现线程间的共享!
2. 局部变量放置于栈中。
3. 栈是由系统自动分配,速度快!栈是一个连续的内存空间!
堆 heap:
1. 放置new出来的对象!
2. 堆是一个不连续的内存空间,分配灵活,速度慢!
方法区(也是堆):
4. 被所有线程共享!
5. 用来存放程序中永远是不变或唯一的内容。(类代码信息、静态变量、字符串常量)
一、 封装
我们程序设计要追求“高内聚,低耦合”
。
高内聚:就是类的内部数据操作细节自己完成,不允许外部干涉;
低耦合:仅暴露少量的方法给外部使用
封装简单理解就是数据的隐藏。有必要决定这些特性的可见性,即哪些特性对外部 可见的,哪些特性
用于表示内部状态。
封装步骤
- 使用private修饰要封装的成员变量。
- 提供一个公开的方法设置或者访问私有的属性
1. 设置set方法,命名格式set属性名();属性名需要大写。
2. 访问通过get方法,命名格式:get属性名();属性的首字母要大写。
【演示】对象能访问public定义的内部;
//对象能在类的外部"直接"访问
public class Student{
public String name;
public void println(){
System.out.println(this.name);
}
}
public class Test{
public static void main(String[] args){
Student s = new Student();
s.name = "tom"; } }
================================
//如果使用private关键字把数据隐藏起来,外部不能直接访问
public class Student{
private String name;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
}
public class Test{
public static void main(String[] args){
Student s = new Student();
//编译报错,在类的外部不能直接访问类中的私有成员
//s.name = "tom";
//那么可以在类中提供对于的get和set方法,以便让用户在类的外部可以间接的访问到私有属性
s.setName("tom");
System.out.println(s.getName());
} }
意义和作用
- 提高程序的安全性,保护数据。
- 隐藏代码的实现细节
- 统一用户的调用接口
- 提高系统的可维护性
- 便于调用者调用。
良好的封装,便于修改内部代码,提高可维护性。
良好的封装,可进行数据完整性检测,保证数据的有效性。
方法重载
类中有多个方法,有着相同的方法名
,但是方法的参数各不相同
,这种情况被称为方法的重载
方法重载必须满足以下条件
- 方法名必须相同
- 参数列表必须不同(参数的类型、个数、顺序的不同)
- 方法的返回值可以不同,也可以相同。
public class Test{
public void test(String str){ }
public void test(int a){ }
public void test(Strig str,double d){}
public void test(Strig str){}
public void test(Strig str,double d){}
public void test(double d,Strig str){}
}
二、继承
继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。
第一好处:继承的本质在于抽象。类是对对象的抽象,继承是对某一批类的抽象。
第二好处:为了提高代码的复用性。
extands的意思是“扩展”。子类是父类的扩展。
- 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的俩个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
- 类和类之间的继承是单继承
一个子类只能"直接"继承一个父类,就像是一个人只能有一个亲生父亲
一个父类可以被多子类继承,就像一个父亲可以有多个孩子
- 父类中的属性和方法可以被子类继承
子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public protected default private)相关的。
父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用
super关键字
父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用
super关键字)。
子类继承父类之后,在子类中可以使用this
来表示访问或调用子类中的属性或方法
, 使用super
就表示访问或调用父类中的属性和方法。
【访问父类中的属性】
public class Person{
protected String name = "zs";
}
public class Student extends Person{
private String name = "lisi";
public void tes(String name)t{
System.out.println(name); //zs
System.out.println(this.name); //lisi
System.out.println(super.name); //zs
} }
【调用父类中的方法】
public class Person{
public void print(){
System.out.println("Person");
}
}
public class Student extends Person{
public void print(){
System.out.println("Student");
}
public void test(){
print(); //Student
this.print();//Student
super.print(); //Person
} }
【调用父类中的构造器】
public class Person{
//编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器
/*
protected String name;
public Person(String name){
this.name = name;
}
*/
}
public class Student extends Person{
//编译通过,子类构造器中会隐式的调用父类的无参构造器
//super();
public Student(){ }
}
【显式的调用父类的有参构造器】
public class Person{
protected String name;
public Person(String name){
this.name = name; } }
public class Student extends Person{
//编译通过,子类构造器中显式的调用父类的有参构造器
public Student(){ super("tom");
} }
不管是显式还是隐式的父类的构造器,super
语句一定要出现在子类构造器中第一行代码。所以this和super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。
public class Person{
protected String name;
public Person(String name){
this.name = name;
} }
//编译通过
public class Student extends Person{
private int age;
public Student(){
this(20); }
public Student(int age){
super("tom");
this.age = age;
} }
【super 和 this 的区别】
1. 代表的事物不一样:
this:代表所属方法的调用者对象。
super:代表父类对象的引用空间。
2. 使用前提不一致:
this:在非继承的条件下也可以使用。
super:只能在继承的条件下才能使用。
3. 调用构造方法:
this:调用本类的构造方法。
super:调用的父类的构造方法
3.Object类
java中的每一个类都是"直接" 或者 "间接"的继承了Object类.所以每一个对象都和Object类有"is a"的关系。从API文档中,可以看到任何一个类最上层的父类都是Object。(Object类本身除外)AnyClass is a
Object。
例如:toString方法、equals方法、getClass方法等
System.out.println(任何对象 instanceof Object);
//输出结果:true //注:任何对象也包含数组对象
4. 方法重写
-
方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载,不
能被重写 -
静态方法不能重写
1. 父类的静态方法不能被子类重写为非静态方法 //编译出错
2. 父类的非静态方法不能被子类重写为静态方 法;//编译出错
3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
A类继承B类 A和B中都一个相同的静态方法test
B a = new A(); a.test();
//调用到的是B类中的静态方法
test A a = new A();
a.test();
//调用到的是A类中的静态方法test
可以看出静态方法的调用只和变量声明的类型相关 这个和非静态方法的重写之后的效果完全不同
- 私有方法不能被子类重写,子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。
public class Person{
private void run(){} }//编译通过,但这不是重写,只是俩个类中分别有自己的私有方法
public class Student extends Person{
private void run(){}
}
方法重写的时候,子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected <
public,friendly < public)
4.多态
多态可以让我们不用关心某个对象到底是什么具体类型,就可以使用该对象的某些方法,从而实现更加灵活的编程,提高系统的可扩展性。
允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
相同类域的不同对象,调用相同的方法,执行结果是不同的
- 一个对象的实际类型是确定的
例如: new Student(); new Person();等
- 可以指向对象的引用的类型有很多
例如: Student继承了Person类
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
一个对象的实际类型是确定,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型。
调用到的run方法,是Student从Person继承过来的run方法
public class Person{
public void run(){}
}
public class Student extends Person{
public void run(){ //重写run方法 }
}
//调用到的run方法,是Student中重写的run方法
main:
Person p = new Student();
p.run();
重写、重载和多态的关系
重载是编译时多态
重写是运行时多态
多态是方法的多态,属性没有多态性。
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
那么以下三种类型的方法是没有办法表现出多态特性的(因为不能被重写):
4. static方法,因为被static修饰的方法是属于类的,而不是属于实例的
5. final方法,因为被final修饰的方法无法被子类重写
6. private方法和protected方法,前者是因为private修饰的方法对子类不可见,后者是因为尽管被protected修饰的方法可以被子类见到,也可以被子类重写,但是它是无法被外部所引用的,一个不能被外部引用的方法,怎么能谈多态呢。