1.面向对象的概念
使用类映射现实生活中的事务,其功能封装为方法,属性封装为成员变量.
一个类拥有的成员包括:成员变量,构造方法,普通方法,getters/setters
如一个person类:
class Person{
private String name;
private int age;
public Person(){}
public Person(String name,int age) {
this.name = name;
this.age = age;
}
public void showName() {
System.out.println(this.name);
}
set/get方法
}
2.对象的内存解释
对象在内存中的位置:
对象由new关键字创建,如同数组,实体存在于堆内存中
任何事物均可以定义成类,创建对象,属于引用类型
而对象的引用变量是一个普通变量,存储的值是该对象堆内存中的地址
基本类型赋值代码解释
3.this关键字概念
this一般出现在类的一个方法的定义当中,代表当前对象的引用,我们通常用其将本对象中的成员与其他作用域区分开来
当一个类定义好以后,如果不创建对象this是没有意义的
一个类可以有多个对象,每个对象都有各自的属性值,各个对象的方法均是类中定义的那个方法逻辑.定义中的this就代表调用这个方法的对象
4.匿名对象
匿名对象没有引用的对象,没有名字的对象,与有名字的对象对比如下:
Person p = new Person(),该对象是有名字为p的一个person对象,可以调用方法.
5.组合关系的概述
当一个自定义类型A的成员变量的数据类型是自定义类型B时,A类与B类叫做组合关系
6.继承的概述
继承是代码复用的重要方式,是类与类之间的一种关系
从类与类之间的设计关系来看,,子类必须属于父类的一种时,才会继承
父类抽取出了共性的内容,子类可以在父类基础上扩展新的属性与行为
子类拥有父类的所有属性与方法,无需重新定义,并且可以直接使用非私有的父类成员
7.继承格式说明
使用extends关键字完成继承关系
所有的类都直接或间接继承自object,所以如果没有继承其他类,则默认继承object类,object是所有类的父类
class 子类 extends 父类{}
8.子类通过get/set方法访问父类成员变量
当父类的创元变量用private修饰后,子类无法访问父类的成员变量,
但是如果父类提供了public修饰的get/set方法,则子类可以通过get/set方法,正常访问父类的成员变量
9.继承的特点
java支持单继承,
java支持多层继承
父类定义了继承树中共性的内容,子类定义了该类个性内容
10.方法重写的概念
当子类继承父类后,拥有了父类的成员并可以直接调用父类非私有方法,如果子类认为父类提供的方法不够强大,
子类可以按照子类自身的逻辑重新定义继承过来的父类方法,这个重新定义父类方法的过程叫做方法重写
方法重写后,调用该方法时不再调用父类的方法,而调用子类重写后的方法
比如:当描述一个人类(父类)时，它具有吃饭，睡觉等功能
中国人类(子类)吃饭比较复杂，使用筷子吃饭，则可以继承原有的人类。并重写吃饭功能，在其中修改为更为复杂的用筷子吃的逻辑即可。
11.override注释
字符重写父类是在方法上添加 @Override注解,表示该方法时子类重写父类中的方法。
/*
* 父类Animal
*/
public class Animal {
public void eat() {
System.out.println("吃东西!");
}
public void sleep() {
System.out.println("睡了!");
}
}
/*
* 子类狗类增强父类的吃饭方法,于是可以重写该方法
*/
public class Dog extends Animal{
//方法重写的注解
@Override
public void eat() {
System.out.println("吃骨头!");
}
// @Override用于限定该方法必须是重写父类的方法
// @Override
// public void eet() {
// System.out.println("吃骨头!");
// }
}
12.方法重写注意事项
方法名称必须相同,参数列表必须相同,访问权限相同或子类方法访问权限更大(访问权限顺序public>默认),返回值为一般必须相同
13.继承中子父类产生顺序概述
在每次创建子类对象时,我们均会先创建父类对象,在创建其子类对象本身,目的在于子类对象中包含了其对应的父类对象空间,
便可以包含其父类对象的成员,如果父类成员非private修饰,则子类可以随意使用父类成员
简单来说就是在子类的构造方法调用时要先调用父类的构造方法
父类:
public class Fu {
private String name;
public Fu() {
// super();
System.out.println("父类的空参构造方法被调用了");
}
public Fu(String name) {
// super();
this.name = name;
System.out.println("父类的带参构造方法被调用了");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
子类:
public class Zi extends Fu {
public Zi() {
super();//这个super语句决定了子类构造方法调用父类空参构造
System.out.println("子类的构造方法被调用了");
}
}
验证:
public static void main(String[] args) {
//创建子类对象,验证注释部分的结论
Zi zi = new Zi();
}
父类:
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
子类:
/*
* 在父类Person的基础上,多了地址属性
* Chinese子类
* address
*/
public class Chinese extends Person {
private String address;
public Chinese() {
super();
}
//定义三个参数的构造方法,无需了解细节,在super的讲解时会详细介绍
public Chinese(String name, int age,String address) {
super(name, age);
this.address = address;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
测试:
//创建子类对象
Chinese c = new Chinese("张三",23,"重庆");
//调用该类方法
System.out.println(c.getName()+"住在"+c.getAddress());
继承后对象的内存图
14.this和super访问注意事项
调用普通成员:
this.成员变量 可以访问本类对象的成员变量
super.成员变量 可以访问父类对象的成员变量
this.成员方法 可以访问本类对象的成员方法
super.成员方法 可以访问父类对象的成员方法
子类方法中
访问子类自身的成员用this
访问父类的成员super
就近原则
局部 > 本类成员 > 父类成员
15.super调用父类构造方法的格式
调用构造方法:
this(其他参数) 可以访问本类其他的构造方法
super(其他参数) 可以访问父类其他的构造方法
默认子类调用父类构造方法
子类的每个构造方法中均有默认的super(),调用父类的空参构造,手动调用父类构造会覆盖默认的super().
//父类
public class Person {
private String name;
private int age;
public Person() {
System.out.println("父类空参构造");
}
public Person(String name, int age) {
System.out.println("父类带参构造");
this.name = name;
this.age = age;
}
public void eat() {
System.out.println("吃饭");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//子类
/*
* 子类可以使用super(参数)调用父类的构造方法
*/
public class Chinese extends Person {
public Chinese() {
System.out.println("子类的空参构造方法");
}
public Chinese(String name,int age) {
super(name,age);
System.out.println("子类的带参构造");
}
@Override
public void eat() {
System.out.println("子类吃饭");
}
}
//测试类
/*
* super在子类中调用父类的构造方法
* this在子类中调用子类其他的构造方法
* 子类构造方法中,要么第一行是super调用父类构造,要么是this调用子类构造,
* 其最终原则就是先有父类内容,再有子类对象
*
* 子类的每个构造方法中均有默认的super(),调用父类的空参构造。手动调用父类构造会覆盖默认的super();
*/
public class Demo01this_super_constructors {
public static void main(String[] args) {
//测试:子类调用父类的带参构造
Chinese c = new Chinese("杰克",18);
System.out.println(c.getAge()+"岁的"+c.getName());
}
}
16.this访问子类构造方法
在子类构造中使用this()或this(参数类型 参数值...)的方法可以调用本类中的其他构造方法,但是最终都是要调用父类的构造方法,完成父类成员的初始化
父类同上
子类:
/*
* 子类可以使用super(参数)调用父类的构造方法
*/
public class Chinese extends Person {
public Chinese() {
//使用this调用本类的两个参数的构造
this("默认",20);
System.out.println("子类的空参构造方法");
}
public Chinese(String name,int age) {
super(name,age);
System.out.println("子类的带参构造");
}
@Override
public void eat() {
System.out.println("子类吃饭");
}
}
测试:
/*
* super在子类中调用父类的构造方法
* this在子类中调用子类其他的构造方法
* 子类构造方法中,要么第一行是super调用父类构造,要么是this调用子类构造,
* 其最终原则就是先有父类内容,再有子类对象
*
* 子类的每个构造方法中均有默认的super(),调用父类的空参构造。手动调用父类构造会覆盖默认的super();
*/
public class Demo01this_super_constructors {
public static void main(String[] args) {
//测试:子类调用父类的带参构造
Chinese c = new Chinese("杰克",18);
System.out.println(c.getAge()+"岁的"+c.getName());
System.out.println("==================");
//测试:子类调用子类的其他构造
Chinese c2 = new Chinese();
System.out.println(c2.getAge()+"岁的"+c2.getName());
}
}