- 1.Java面向对象
- 1.1什么是面向对象？
- 1.2类和对象
- 1.3定义类
- 1.4构造函数
- 1.5创建对象
- 1.6this关键字
- 1.7方法重载
- 1.8成员变量和局部变量
- 1.9封装
- 1.9.1什么是封装
- 1.9.2封装的步骤
- 1.9.3 static 关键字
- 1.10继承
- 1.10.1什么是继承
- 1.10.2子类访问父类
- 1.10.3子类访问权限
- 1.10.4方法重写
- 1.10.5方法重写 VS 方法重载
- 1.11多态
- 1.11.1什么是多态
- 1.11.2多态的使用
- 1.11.3抽象方法和抽象类
面向对象是一种编程思想，将程序中的所有参与角色全部抽象成对象，通过对象之间的相互调用来实现业务功能。
1.1什么是面向对象？面向过程，面向功能划分的软件设计结构，自上向下，将一个大问题分解成多个小问题。
例子：
面向过程: 开车去天津，整个过程每一步都需要进行记录（开门，坐好，踩油门等等），非常麻烦，同时制约了程序的扩展性和维护性。
面向对象：开车去天津，抽象出 3 个对象：你、汽车、天津，忽略了过程中的每一个细节
面向过程注重的是每一个步骤，面向对象注重整个需求的模块化结构
面向对象的核心思想就是重用性以及扩展性和灵活性
1.2类和对象每个对象都有各自的特征：
1、属性：对象的静态特征
2、方法：对象的动态特征
对象就是用来描述客观存在的一个实体，该实体由一组属性和方法组成。
类是产生对象的模板，所有的对象都是通过类来创建的
类和对象的关系：类是对象的抽象化描述，将不同对象共有的特性（属性和方法）抽象出来的一个模板，对象是类的具体实例。
例子：宠物狗（类）：小白（对象）、小黑（对象）、小兰（对象）
一个类可以创建出很多个对象，一个对象归属于一个类
类是抽象概念，是一种描述，仅仅是模板，对象是实实在在具体的存在。
1.3定义类基本语法
public class 类名{
//定义属性
public 数据类型 属性名;
//定义方法
public 返回值类型 方法名(参数列表){
//方法体
}
}
方法的定义有两个重点：返回值类型和参数列表
返回值：有返回值和无返回值
有返回值的方法需要在方法定义时指定返回值的数据类型，在方法体中用 return 将结果进行返回。
无返回值是指该方法不需要进行结果的返回。无返回值方法直接调用
参数是指要传入到方法中进行业务逻辑处理的数据
试试定义一个User类
public class User {
//定义属性
public int id;
public String name;
public char gender;
public String password;
//定义方法
public void show(){
System.out.println("展示用户信息");
}
}
很多不同名字：构造函数、构造方法、构造器 都是构造函数的意思
Java 通过类的构造函数来创建对象，构造函数是一种特殊的方法，方法名必须和类名保持一致，不需要进行返回值类型的定义，基本语法如下:
public 构造函数名 (参数列表){
}
构造函数包括有参构造和无参构造，区别在于是否有参数
public User(){
}
public User(int id,String name,char
gender,String password){
this.id = id;
this.name = name;
this.gender = gender;
this.password = password;
}
构造函数包括有参构造和无参构造，区别在于是否有参数每个类都会有一个默认的无参构造函数，我们在定义类的时候不需要声明无参构造函数。
如果我们不声明无参构造函数，手动定义了一个有参构造，则默认的无参构造会被覆盖。
1.5创建对象创建对象只需要调用类的构造函数即可，调用无参构造创建对象，只会创建对象，不会给对象的属性进行赋值。
User user = new User();
user.id = 1;
user.name = "张三";
user.gender = '男';
user.password = "123123";
调用有参构造，可以直接将属性的赋值工作在构造器内部完成，外部在创建对象的时候就不需要进行属性的赋值了，只需要将属性值通过有参构造的参数列表传入方法内部即可。
public User(int id,String name,chargender,String password){
this.id = id;
this.name = name;
this.gender = gender;
this.password = password;
}
User user = new User(1,"张三",'男',"123123");
this 用来指代当前类的实例化对象，通过 this 可以调用当前类的属性和方法，比如构造器中，可以通过 this 来完成对属性的赋值。
public User(int id,String name,chargender,String password){
this.id = id;
this.name = name;
this.gender = gender;
this.password = password;
}
User user = new User(1,"张三",'男',"123123");
this 除了可以在类中访问属性也可以在类中调用方法，方法：构造函数和普通方法
调用构造函数：this(参数列表);
public User(){
this(1,"张三",'男',"123123");
}
public User(int id,String name,char gender,String password){
this();
this.id = id;
this.name = name;
this.gender = gender;
this.password = password;
}
调用普通方法：this.方法(参数列表);
1.7方法重载构成重载的条件：
-
在同一个类中
-
方法名相同
-
参数列表不同（个数或者类型不同）
-
与返回值和访问权限修饰符无关
例子，以下哪些情况不属于方法重载？AD
A. public int test(){}
public int test(){}
B. public double test(double a,double b){}
public double test(){}
C. public String test(){}
public void test(int a){}
D. public void test(){}
public void test2(){}
变量的作用域范围是不同的
作用域：程序中可以通过变量名来访问该变量的范围
变量被声明时所在位置决定作用域
成员变量：如果一个变量在方法外，类中声明，则它是成员变量
局部变量：如果一个变量在方法中被声明，则它是局部变量
public class Test {
//成员变量
String name = "张三";
public void show(){
//局部变量
int num = 10;
}
}
成员变量作用域在整个类中，类中的每个方法都可以访问该变量
局部变量作用域只在定义该变量的方法中，出了方法就无法访问
当成员变量和局部变量名称冲突的时候，局部变量的优先级更高
成员变量会有默认值，局部变量没有默认值
1.9封装 1.9.1什么是封装 封装就是将类的信息全部隐藏到内部，外部不能直接进行赋值和访问，必须通过类中提供的方法来进行访问和赋值，我们可以在方法中添加逻辑处理来实现过滤，屏蔽错误数据的赋值。
1.9.2封装的步骤-
修改属性的访问权限，使得外部不能直接访问
-
提供外部可以直接调用的方法
-
在方法中加入属性控制逻辑
例子：id只能大于零
public class User { //定义属性 private int id; private String name; private char gender; private String password; //定义方法 public void show(){ System.out.println("展示用户信息"); System.out.println("id:" + this.id); System.out.println("name:" + this.name); System.out.println("gender:" + this.gender); System.out.println("password:" + this.password); } public int getId() { return id; } public String getName() { return name; } public char getGender() { return gender; } public String getPassword() { return password; } public void setId(int id){ if(id <= 0){ System.out.println("id数值错误，已处理 为默认值"); this.id = 1; }else{ this.id = id; } } public void setName(String name) { this.name = name; } public void setGender(char gender) { this.gender = gender; } public void setPassword(String password) { this.password = password; }IDEA的set和get方法 快速生成
static 表示静态或者全局，可以用来修饰成员变量、成员方法、代码块
用 static 修饰的成员变量和成员方法不需要再依赖于具体对象，可以直接通过类来方法，也可以通过任意一个对象访问
用 static 修饰之后的成员变量叫做静态变量
用 static 修饰之后的成员方法叫做静态方法
静态变量和静态方法多个对象共用的，内存中只有一份
没有用 static 修饰的成员变量和成员方法，一个对象对应一个，内存中有多分，不是所有对象共享的
public class User {
public static String name;
public static void show(){
System.out.println("这是一个User对象");
}
}
public class Test {
public static void main(String[] args) {
User.name = "张三";
System.out.println(User.name);
User.show();
}
}
static 修饰的成员方法叫做静态方法，静态方法中不能使用this关键字。this指的是对象
1.10继承 1.10.1什么是继承一个类继承另外一个类的属性和方法，被继承的类叫做父类，继承父类的类叫做子类。
public class People {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 class Student extends People {
}
public class Teacher extends People {
}
一个类只能有一个直接父类
继承父类的属性和方法，还可以继续扩展自己的属性和方法
1.10.2子类访问父类实现了继承关系的父子类，在创建子类对象的时候，无论调用有参构造还是无参构造，都会默认优先创建父类对象，并且是默认通过无参构造创建父类对象。
Java 中的每个类都有一个共同的父类 Object，所有的 Java类都是由 Object 类派生出来的。
想调用父类的有参构造，super 关键字，用于子类访问父类的属性和方法
public class Student extends People {
private char gender;
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public Student() {
super(1,"张三",22);//调用父类有参构造
System.out.println("无参构造创建Student对
象");
}
public Student(char gender) {
super(1,"张三",22);//调用父类有参构造
System.out.println("有参构造创建Student对
象");
}
}
super.属性
super.方法(参数列表
public void show(){
super.setName("张三");//调用父类的set方法
System.out.println(super.getName());
}
访问权限修饰符，修饰类、属性、方法
public、protected、默认、private
属性、方法：
包 package：用来管理 Java 类
包的作用：
1、管理 Java 类，便于查找文件
2、区分同名的类，防止命名冲突
3、实现访问权限的控制
包的命名规范：小写字母，.(点)用来分层
1.10.4方法重写子类在继承父类方法的基础上，对父类方法进行覆盖
//父类方法
public class People {
private int id;
public void setId(int id) {
this.id = id;
}
public void show(){
System.out.println("输出人员信息");
}
}
//子类方法重写
public class Student extends People {
@Override
public void show() {
System.out.println("这是一个学生");
}
}
构造方法不能被重写
规则：
- 父子类方法名相同（show)
- 父子类方法参数列表相同
- 子类方法返回值与父类方法返回值相同或是子类方法返回值是父类方法返回值的子类（double是number的子类）
- 子类方法的访问权限不能小于父类（参照子类的访问权限）
| 所在位置 | 方法名 | 参数列表 | 返回值 | 访问权限 | |
|---|---|---|---|---|---|
| 方法重写 | 子类 | 相同 | 相同 | 相同或者是父类返回值的子类 | 不能小于父类 |
| 方法重载 | 同一个类 | 相同 | 不同 | 没有要求 | 没有要求 |
一个事物有多种表现形态
定义一个方法，在具体的生成环境中根据不同的需求呈现出不同的业务逻辑
不使用多态：普通会员买书打9折，超级会员买书打6折
//OrdinaryMember 普通会员
package book;
public class OrdinaryMember {
public void buyBook(){
System.out.println("普通会员买书打9折");
}
}
//Cashier 前台买书方法
package book;
public class Cashier {
private OrdinaryMember ordinaryMember;
public OrdinaryMember getOrdinaryMember() {
return ordinaryMember;
}
public void setOrdinaryMember(OrdinaryMember ordinaryMember) {
this.ordinaryMember = ordinaryMember;
}
public void settlement(){
this.ordinaryMember.buyBook();
}
}
//Test 运行
package book;
public class Test {
public static void main(String[] args) {
OrdinaryMember ordinaryMember = new OrdinaryMember();
Cashier cashier = new Cashier();
cashier.setOrdinaryMember(ordinaryMember);
cashier.settlement();
}
}
输出结果：普通会员买书打9折
如果变成超级会员买书打6折，需要修改大量代码
多态情况
package book;
public class Member {
public void buyBook(){
}
}
package book;
public class OrdinaryMember extends Member {
public void buyBook(){
System.out.println("普通会员买书打9折");
}
}
package book;
public class SuperMember extends Member {
public void buyBook(){
System.out.println("超级会员买书打6折");
}
}
package book;
public class Cashier {
private Member member;
public Member getMember() {
return member;
}
public void setMember(Member member) {
this.member = member;
}
public void settlement(){
this.member.buyBook();
}
}
package book;
public class Test {
public static void main(String[] args) {
OrdinaryMember ordinaryMember = new OrdinaryMember();
SuperMember superMember = new SuperMember();
Cashier cashier = new Cashier();
cashier.setMember(superMember);//换成不同的对象
cashier.settlement();
}
}
//cashier.setMember(superMember); 输出结果为：超级会员买书打6折
//cashier.setMember(ordinaryMember);输出结果为：普通会员买书打9折
- 定义方法时形参类型为父类，调用方法时传入的参数为子类对象
- 定义方法时返回值类型为父类，调用方法时返回子类对象
子类重写父类方法来实现多态，从而提高程序的扩展性、维护性‘
子类重写父类方法时，父类方法无论写什么都不会展现，此时可以定义为抽象方法和抽象类
抽象方法：只有方法的声明，没有方法的定义，通过给方法添加 abstract 关键字来实现，一旦某个方法被定义为抽象方法，则该方法所在的类必须声明为抽象类。
抽象类与普通类的区别是抽象类不能被实例化
抽象方法和普通方法的区别是抽象方法没有方法体。
父类中包含抽象方法，则子类必须要实现该方法，如果子类也是抽象类，则可以不用实现该方法。
抽象类中可以没有抽象方法，但是普通类中不能定义抽象方法。
父类中包含抽象方法，则子类必须要实现该方法，重写
如果子类也是抽象类，则可以不用实现该方法。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）