第一部分
***主要知识点
l 面向对象的理解
l 类与对象
l private关键字
l 封装
l this关键字
l 继承&方法重写
l 构造方法
1.面向对象
1.1面向对象的概述
面向对象是Java的基本特征。深刻地理解面向对象是设计良好Java软件项目的基础。
面向对象(Object Oriented,OO)是软件开发过程中使用的一种思维方式 。将功能封装进对象,强调具备了功能的对象,不关注过程。
面向对象是依赖于面向过程。
例如:我们要吃饭时,自己做饭是面向过程的思维过程。
我们要吃饭时,思考的是去调用饭店提供饭的功能,无需再详细地去解决问题是面向对象的思维过程。
例如:我想买一个电脑,但是我不知道买什么样的好,不懂配置,所以我就找了一个懂电脑配置的人来帮我去买,这样我就从一个执行者变成了一个指挥者,指挥这个人来帮我买电脑,而我找的这个人就是我创建的对象
1.2面向对象的特点
l 是一种更符合人们思考习惯的思想
l 可以将复杂的事情简单化
l 将程序由执行者转换成为指挥者
1.3面向对象的特性
l 封装、继承、多态
2.类与对象
2.1类的基本概念
l 具有相同特征(属性)和行为(功能)的一类事物的抽象。
l 类在Java中代码的体现形式:
l 使用class(类)来抽象一个现实生活中的事物
l 定义成员变量对应事物的属性,用private修饰,提供get/set方法
l 定义成员方法对应事物的功能
l 定义格式:
public class 类名{
// 成员变量----- 属性
private 数据类型 变量名1;
private 数据类型 变量名2;
…其他成员变量
//成员方法----- 行为
public 返回值类型 方法名(参数类型 参数名,参数类型 参数名2…) {
方法体;
}
每个属性对应的get/set方法
}
示例1:定义一个人类,在人类中有两个成员变量,和吃饭的功能。并给每个属性提供相应的get/set方法 代码: //人类 public class Person { String name; int 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; }
public void eat() { System.out.println("人要吃饭"); }
}
|
2.2类的使用格式
类的使用非常简单,一般分为两个动作:创建对象与调用方法。
类的定义是现实事物的抽象,真正使用的是类创建的对象。通常使用对象来调用方法。
l 对象创建格式:
数据类型 对象名= new 数据类型();
l 对象方法的调用:
无返回值:
对象名.方法名(参数);
有返回值:
返回值类型 变量名 = 对象名.方法名(参数);
示例2: 定义一个人类,在人类中有两个成员变量,和吃饭的功能。并给每个属性提供相应的get/set方法,在测试类中给属性赋值,调用eat方法,并将属性打印在控制台上 代码: //人类 public class Person { String name; int 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; }
public void eat() { System.out.println("人要吃饭"); }
}
public class Test { public static void main(String[] args) { Person p = new Person(); p.setName("柳岩"); p.setAge(30); System.out.println(p.getName()+"---"+p.getAge()); p.eat(); } } |
2.3成员变量
直接定义在类中的变量称为成员变量,在面向对象思想设计上,是类的组成部分。
成员变量通常使用private修饰,阻止本类以外的其他类访问。
成员变量不能重名,局部变量不能重名,成员与局部变量可以重名,但是需要使用this区分。
使用this访问的为成员变量,直接访问的为局部。在方法内访问变量,如果没有该名称的局部变量会自动查找是否有该名称的成员变量。
2.4成员方法
正常定义成员方法时,一般是不需要添加static修饰符的。static修饰符会在后边详细简介。
成员方法一般可分为两类
l 没有业务的属性get/set方法,与属性对应
l 有业务的普通方法,属于类的功能
示例1:以上案例中Person类中的name和age就是定义在类中方法外,属于成员变量 get/set方法和我们自己定义的eat方法都是成员方法 |
2.5类与对象的关系
类是抽象概念,对象是类的具体实例。我们通常真正使用的是某个类的实例对象,进而调用该对象的方法。
一个类可以有多个对象,一个对象只属于一个类(在讲完多态后会有不同的理解)。
可以说创建对象并调用方法是类最主要的使用方式。
3.封装
3.1封装的概念
l 隐藏实现细节,提供公共访问方式,就叫封装
l 体现:类、private修饰的成员变量、成员方法以及公共的get/set方法均为封装的一部分。
l setXxx()--->用做给我们的属性赋值
l getXxx()--->用做取值
3.2 private关键字
l private关键字是私有化修饰符,访问权限修饰符的一种,只有在本类中才能访问的成员,是封装类中成员变量最常用的修饰符。
l 用于修饰成员,包括成员变量与成员方法。
3.3 this关键字
l this代表当前对象的引用。我们通常 来新用其将本对象中的成员与其他作用域成员区分开来。
l this.属性名 ------ 指的是成员变量,用来区分成员变量和局部变量
3.3.1封装案例1
题干 | 编写代码,实现以下功能: 定义一个门类Door 门类有2个属性,宽度 width 和 高度 height。要求属性私有,提供set get方法 门类有 开门openDoor 和关门closeDoor 的方法 开门方法:在控制台输出“门已经打开,请进!” 关门方法:在控制台输出“门已经关闭,禁止进入!
定义一个测试类,测试类中定义一个main方法 在main方法中创建一个门对象,使用创建出的门对象 调用门的开门和关门方法。用set方法为属性赋值 宽为1.5 高为 2 。然后获取属性值 |
所属知识点 | 封装 |
题目类型 | 代码题 |
答案 | public class Demo01_fengZhuang { public static void main(String[] args) { //创建一个Door对象 Door door = new Door(); //对属性赋值 door.setWidth(1.5); door.setHight(2); //获取属性值 System.out.println("门的宽度为:" + door.getWidth() + ",门的高度为:" + door.getHight()); //调用开门方法 door.openDoor(); //调用关门方法 door.closeDoor(); } }
class Door { //定义属性 private double width; private double hight;
// set get 方法 public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public double getHight() { return hight; } public void setHight(double hight) { this.hight = hight; } //开门方法 public void openDoor(){ System.out.println("门已经打开,请进!"); } //关门方法 public void closeDoor(){ System.out.println("门已经关闭,禁止进入!"); } } |
3.3.2封装案例2
题干 | 编写代码,实现以下功能: 分析: 手机的属性: 品牌,颜色 手机的功能: 打电话 用到的知识:运用private来修饰,来提供访问权限
测试类: 创建手机类对象;调用set方法为手机的属性赋值,打印出赋值后的属性;调用功能方法
|
所属知识点 | 封装 |
题目类型 | 代码题 |
答案 | public class Test { public static void main(String[] args) { //创建手机类的对象 Phone p = new Phone(); //调用set方法,为手机类赋值 p.setName("诺基亚"); p.setColor("屎黄"); //调用get方法获取我们赋值的内容 System.out.println(p.getName()+"-----"+p.getColor()); //对象调用手机类的方法 p.call(); } } class Phone { //品牌 颜色,用private来修饰-->这两个属性成为成员变量-->定义在类中,方法外 private String name; private String color; //提供get/set方法 public String getName() { return name; } //set方法中的参数成为局部变量-->定义在方法内 public void setName(String n) { this.name = n; }
public String getColor() { return color; }
public void setColor(String c) { this.color = c; } //手机的功能 public void call(){ System.out.println("打电话"); } } |
4.继承
4.1继承的概念
当一个类的属性与行为或者换成相反的角度来看,如果多个类具有相同的属性和行为,我们可以抽取出共性的内容定义父类,这时再创建相似的类时只要继承父类即可。
均与现有类相似,属于现有类的一种时,这一个类可以定义为现有类的子类。
子类拥有父类的所有属性与方法,无需重新定义。并且可以直接使用非私有的父类成员。
从类与类之间的设计关系来看,子类必须属于父类的一种时,才会继承。
我们在完成一个庞大项目体系的时候,都是将共性的内容抽取出,后续构建过程是从各种父类“向外”扩散的。
l 比如:猫,狗都属于动物类,而动物都会吃饭,我们就可以抽取出共性的内容,将我们的动物定义成父类,而猫和狗都属于动物类的子类,那么当我们定义猫和狗类的时候就可以继承动物类的吃饭的功能
l
l 但是,子类继承父类是继承子类们共有的,但是我们的子类中还可以定义自己特有的。比如:猫和狗继承动物类吃饭的功能后,猫类中还可以有抓老鼠的功能;狗类中还可以定义看门的功能
l 4.2继承的定义格继承的定义格式:
class 子类 extends 父类{
//父类的非私有方法与属性均继承过来
}
式以及使用格式
如:
父类的定义:
class Person{
private String name;
public void eat(){
System.out.println(“吃饭”);
}
get/set方法
}
子类继承父类的定义:
class Chinese extends Person{}
l 继承的使用格式:
继承关系的产生通常是为了定义出功能更为具体、更为强大的子类。所以,定义子类后,一般创建子类对象使用。子类可以直接使用父类非私有的成员变量与成员方法
(注:如果成员变量没有使用private修饰,则子类也可直接访问。)
子类的使用:
class Test{
public static void main(String[] args) {
Chinese c = new Chinese();
c.setName(“张大力”);
String name = c.getName();
System.out.println(name);//打印结果为张大力
c.eat(); //打印结果吃饭
}
5.方法重写
5.1方法重写概念
l 当子类继承父类后,拥有了父类的成员并可以直接调用父类非私有方法。如果子类认为父类提供的方法不够强大,子类可以按照子类自身的逻辑重新定义继承过来的父类方法,这个重新定义一个方法的过程叫做方法重写。
(注:在学习完多态和抽象类后我们会对方法重写有更深的理解)
l 比如:定义一个人类,在人类中有一个吃饭的功能,子类继承人类后,也有了吃饭的功能,但是怎么吃呢?我们就可以重写人类中吃的方法,方法体中写具体怎么吃。
5.2方法重写的格式
子类中定义与父类一样的方法便将父类的方法重写了。此时,当创建子类对象,调用方法时,会调用子类重写后的方法。如:
类的定义:
class Person{
public void eat(){
System.out.println(“吃饭”);
}
}
class Chinese extends Person{
public void eat() {
System.out.println(“按照中国的习惯,使用筷子吃”);
}
}
子类的使用:
class Test{
public static void main(String[] args) {
Chinese c = new Chinese();
c.setName(“张大力”); //父类继承方法直接调用
String name = c.getName(); //父类继承方法直接调用
System.out.println(name); //打印结果为张大力
c.eat(); //方法重写后调用的为重写后的方法
//打印结果:按照中国的习惯,使用筷子吃
}
}
5.3Java中方法重写规则
l 子类重写方法时,在声明前加@Override可检测该方法是否为重写的方法
l 访问权限相同或子类方法访问权限更大(访问权限顺序public>默认)
l 方法名称必须相同
l 参数列表必须相同
l 返回值为基本类型时必须相同
l 返回值为引用类型时相同或子类小(了解)
5.4继承注意事项
l Java只支持单继承,不支持多继承。
l 父类可以继承他的父类。
l 所有类均有父类,只有Object类没有父类。
l 在所有使用父类类型的地方均可以传入其子类对象。
5.4.1继承案例1:
编写代码,实现以下功能: 需求:定义一个父类,在父类中输出一句话, 定义一个子类,继承父类,并重写父类中的方法,并输出一句话 在测试类中将子类的那句话打印在控制台上
|
继承,重写 |
代码题 |
class Fu { void show() { System.out.println("Fu show"); } } class Zi extends Fu { //子类复写了父类的show方法 void show() { System.out.println("Zi show"); } }
public class Test{ public static void main(String[] args) { Zi z = new Zi(); z.show(); //如果子类中没有show方法,但是可以找到父类方法去执行;如果子 类中有show方法,那么就按照就近原则执行. } } |
5.4.1继承案例2:
题干 | 编写代码,实现如下功能: * (1)定义一个门类, * 包含3个属性:宽度width 和 高度height ,颜色color 包含2个方法:开门和关门 开门方法:输出“门已经打开,请进!” 关门方法:输出“门已经关闭,禁止进入!”
(2)定义一个木头门WOOD,继承Door 重写父类开门方法:输出门的高度 宽度 颜色 +“门已经打开,请进!” 重写父类关门方法:输出门的高度 宽度 颜色 +“门已经关闭,禁止进入!”
(3)定义一个测试类,测试类定义一个main方法 分别创建 门对象 和 木头门对象, 为创建的木头门对象属性赋值, 调用开门和关门两个方法。 |
所属知识点 | 继承,重写 |
题目类型 | 代码题 |
答案 | public class Demo03_jiCheng { public static void main(String[] args) { //创建门对象 Door02 door = new Door02(); // 调用方法 door.openDoor(); door.closeDoor(); //创建木头门对象 WoodDoor woodDoor = new WoodDoor(); //调用set方法对属性赋值 woodDoor.setWidth(1.8); woodDoor.setHight(2.5); woodDoor.setColor("红色"); //调用方法 woodDoor.openDoor(); woodDoor.closeDoor(); } }
class Door02 { //定义属性 private double width; private double hight; private String color; public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public double getHight() { return hight; } public void setHight(double hight) { this.hight = hight; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } //开门方法 public void openDoor(){ System.out.println("门已经打开,请进!"); } //关门方法 public void closeDoor(){ System.out.println("门已经关闭,禁止进入!"); } }
class WoodDoor extends Door02{
//重写开门方法 public void openDoor(){ System.out.println("门的宽度为:"+ getWidth() +",高度为:"+getHight()+",颜色:"+getColor()+",门已经打开,请进!"); } //关门方法 public void closeDoor(){ System.out.println("门的宽度为:"+ getWidth() +",高度为:"+getHight()+",颜色:"+getColor()+",门已经关闭,禁止进入!"); } } |
6.构造方法
6.1构造方法的概念
l 用来创建实例对象的方法。
l 创建对象时,可以直接为成员变量赋值,无需再在对象产生后再赋值。
l 构造方法是必须存在的,没有手动给出构造方法,Java会自动为我们补齐一个空参的构造方法。这个过程我们是看不到的。
l 具体类与抽象类均有构造方法,接口没有构造方法。
l 作用:一、创建对象;二、在创建对象的同时给属性赋值
6.2定义格式
l 一般定义在其他方法前,成员变量后。
l 方法定义格式:没有返回值类型定义,方法名与类名相同
public 类名(参数类型 参数1,参数类型 参数2){
//创建对象时要执行的逻辑,经常为为成员变量赋值
}
如:
public class Person{
private String name;
private int age;
//两个构造方法为重载关系
public Person() {} //空参的构造方法
public Person(String name,int age) { //带参的构造方法
this.name = name;
this.age = age;
}
}
l 使用格式:
构造方法的功能就是创建对象,同时可以为属性赋值。这样当对象创建出来后就已经具备了初始值。
new 类型(实际参数);
如:
//调用set方法赋值
Person p = new Person(); //产生了Person的对象
p.setName(“黄晓明”);
p.setAge(24);
System.out.println(p.getName()+”---”+p.getAge());
//利用构造方法为成员变量赋值
Person p2 = new Person(“AngelaBaby”,18); //产生了一个Person对象
System.out.println(p2); //打印结果为一个对象地址值,如0252b2
System.out.println(p2.getName()+”---”+p2.getAge()); //打印结果为AngelaBaby
6.2.1构造方法案例1:
题干 | 编写代码,实现以下功能: 定义一个门类door 门类有2个属性,宽度 width 和 高度 height。要求属性私有,提供set get方法 无参构造, 满参构造 门类有 开门openDoor 和关门closeDoor 的方法 开门方法:在控制台输出“门已经打开,请进!” 关门方法:在控制台输出“门已经关闭,禁止进入!
定义一个测试类,测试类中定义一个main方法 在main方法中创建一个门对象,使用创建出的门对象 调用门的开门和关门方法。用构造方法为属性赋值 宽为1.5 高为 2 。打印出来,然后再用set方法给属性赋值为宽为3,高为4,5; |
所属知识点 | 继承,构造,封装 |
题目类型 | 代码题 |
答案 | public class Demo01_fengZhuang { public static void main(String[] args) { //创建一个Door对象 Door door = new Door(1.5,2); //获取属性值 System.out.println("门的宽度为:" + door.getWidth() + ",门的高度为:" + door.getHight()); //调用开门方法 door.openDoor(); //调用关门方法 door.closeDoor(); } }
class Door { //定义属性 private double width; private double hight; //无参构造 public Door() { super(); } //带参构造 public Door(double width, double hight) { super(); this.width = width; this.hight = hight; } // set get 方法 public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public double getHight() { return hight; } public void setHight(double hight) { this.hight = hight; } //开门方法 public void openDoor(){ System.out.println("门已经打开,请进!"); } //关门方法 public void closeDoor(){ System.out.println("门已经关闭,禁止进入!"); } } |
6.2.2构造方法案例2:
题干 | 雇员示例需求: 公司中: 定义员工类,类中有 姓名,工号,薪水,工作内容 程序员有 姓名,工号,薪水,工作内容。 项目经理除了有 姓名,工号,薪水,工作内容, 还有奖金。 实现思路: 1:所有的属性私有化;定义工作内容方法 2:员工类中提供无参和满参构造,并提供get/set方法 3:经理类继承员工类中相同属性,并定义特有属性 4程序员类继承员工类,重写员工类的工作内容方法 5:分别在测试类中给程序员和经理的属性赋值,并分别将程序员和经理的属性,方法打印出来
|
所属知识点 | 继承,构造,封装 |
题目类型 | 代码题 |
答案 | class Emplyee //员工 { //姓名,工号,工资 private String name; private String id;//工号 private double salary;//工资 //构造方法 public Emplyee(){} public Emplyee(String name, String id, double salary){ this.name = name; this.id = id; this.salary = salary; } //公共方法 public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setId(String id){ this.id = id; } public String getId(){ return id; } public void setSalary(double salary){ this.salary = salary; } public double getSalary(){ return salary; } public void work(){ System.out.println("工作"); } }
class Programer extends Emplyee// 程序员 { //由于我们已经继承了员工类,那么我们就不需要再定义相同的属性了 //构造方法 public Programer(){} public Programer(String name, String id, double salary){ super(name,id,salary); } public void work(){ System.out.println("程序员工作"); } }
class ProjectManager extends Emplyee// 项目经理 { //由于我们已经继承了员工类,那么我们就不需要再定义相同的属性了,只需要定义我特有的属性就可以了 //成员变量 private double bouns; //奖金 //构造方法 public ProjectManager(){} public ProjectManager(String name, String id, double salary, double bouns){ super(name,id,salary); this.bouns = bouns; } //公共访问方法 setXxx, getXxx() public void setBouns(double bouns){ this.bouns = bouns; } public double getBouns(){ return bouns; } public void work(){ System.out.println("项目经理工作"); } } public class Test { public static void main(String[] args) { Programer p = new Programer(); p.setName("程序员"); p.setId("343242"); p.setSalary(2.5); p.work(); System.out.println(p.getName()+"---"+p.getId()+"---"+p.getSalary()); System.out.println("============================================="); ProjectManager pm = new ProjectManager(); pm.setName("玉皇大帝"); pm.setId("5454"); pm.setSalary(6.3); pm.setBouns(8.6); pm.work(); System.out.println(pm.getName()+"---"+pm.getId()+"---"+pm.getSalary()+"---"+pm.getBouns()); } } |
|
|