Java OPP
Java OPP
一、对象和封装
1、回顾：
1.包名取名规则：字母小写，不能是数字开头
2.类名取名规则：不能是数字开头，首字母大写
2、使用面向对象进行编程设计
面向对象就是抽取过程，可分为三步：
- 发现类
- 发现类的属性
- 发现类的方法
抽象时原则有：
- 属性和方法的设置是发了解决业务问题
- 关注主要属性和方法
- 如没有必要，勿增加额外的类，属性与方法。
遵循以上规则，代码如下：
/*
*宠物狗狗类
*/
public class Dog {
String name = "无名氏"; //昵称，默认值是"无名氏"
int health = 100; //健康值，默认值是100
int love = 0; //亲密度
String strain = "聪明的拉布拉多犬"; //品种
//输出狗狗信息
public void print() {
System.out.println("宠物的自白：\n我的名字叫"+this.name+",健康值是"+this.health+",和主人的亲密度是"+this.love+",我是一只"+this.strain);
}
}
public class Penguin {
String name = "无名氏";
int health = 100;
int love = 0;
String sex = "Q仔";
public void print() {
System.out.println("宠物的自白：\n我的名字叫"+this.name+",健康值是"+this.health+",和主人的亲密度是"+this.love+",性别是"+this.sex);
}
}
在以上代码中可以知道如下步骤：
- 根据控制台提示输入宠物的类型，昵称等内容。
- 根据输入的内容创建相应的宠物对象。
- 输出宠物信息，表示领养成功。
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("欢迎来到宠物店");
//1、输入宠物名称
System.out.println("请输入要领养的宠物名字：");
String name = input.next();
//2、选择宠物类型
System.out.println("请输入要领养的宠物类型：（1、狗狗，2、企鹅）");
switch (input.nextInt()) {
case 1:
System.out.println("请选择狗狗的品种：（1、聪明的拉布拉多犬，2、酷酷的雪纳瑞犬）");
String strain = null;
if (input.nextInt()==1) {
strain = "聪明的拉布拉多犬";
}else {
strain = "酷酷的雪纳瑞犬";
}
Dog dog = new Dog();
dog.name = name;
dog.strain = strain;
dog.print();
break;
case 2:
System.out.println("请选择企鹅的性别：（1、Q仔，2、Q妹）");
String sex = null;
if (input.nextInt()==1) {
sex = "Q仔";
}else {
sex = "Q妹";
}
Penguin pgn = new Penguin();
pgn.name = name;
pgn.sex=sex;
pgn.print();
break;
}
}
}
根据以上，Java中创建对象，调用属性及方法的语法和C#中的相同的：
- 通过构造方法来创建对象，如"Penguin p = new Penguiin();"。
- 通过对象名.属性名的方式调用属性，如"p.name = “qq”;"。
- 通过对象名.方法名的方式调用方法。如"p.print();"。
3、常量：
final:常量修饰符，常量是不可以被修改的，只能赋值一次。
如下代码：
public class Penguin {
String name = "无名氏";
int health = 100;
int love = 0;
final String SEX_MALE = "雄";
final String SEX_FEMALE = "雌";
String sex = SEX_MALE;
public void print() {
System.out.println("宠物的自白：\n我的名字叫"+this.name+",健康值是"+this.health+",和主人的亲密度是"+this.love+",性别是"+this.sex);
}
}
规范：类名、属性名、方法名及常量名的命名规范如下：
- 类名由一个或几个单词组成，每个单词的第一个字母大写，如Dog、StringBuffer。
- 属性名和方法名由一个或几个单词组成，第一个单词首字母小写，其他单词首字母大写。
- 常量由一个或多个单词组成，所有字母大写，如PI、SEX_MALE。
4、构造方法及其重载
Java中的与C#中的构造函数一样，通过无参或参数的构造方法(Constructor)完成赋值的初始化工作。
public class Penguin {
String name = "无名氏";
int health = 100;
int love = 0;
String sex = "Q仔";
//无参构造方法
public Penguin()
{
name="楠楠";
love = 20;
sex="Q妹";
System.out.println("执行构造方法");
}
public void print() {
System.out.println("宠物的自白：\n我的名字叫"+this.name+",健康值是"+this.health+",和主人的亲密度是"+this.love+",性别是"+this.sex);
}
}
在这段代码中，Penguin()方法是Penguin类的构造方法，当在main方法里执行 new Penguin()对象时，默认会输出无参构造函数中的代码。
5、方法重载与继承
方法重载的判断如下：
- 必须在同一个类里
- 方法名相同
- 参数列表（方法参数的个数或参数类型）不同
- 与方法换回值和方法修饰符没有任何关系
在使用this调用自身或super调用父类的其他构造函数时，只能作为第一语句。
6、封装：
类的三大特性：
封装：具体私有化
继承：子承父
多态：一个事物多种形态
**封装：**面向对象的三特性之一，就是将类的状态信息隐藏在类部，不允许外部程序直接访问，而通过该类提供的方法来实现对隐藏信息的操作和访问。
**封装具体步骤：**修改属性的可见性来限制对属性的访问，每个属性创建一对赋值方法和取值方法，用于对这些属性的存取，在赋值方法中，加入对属性的存取控制语句。
**封装的好处：**隐藏类的实现细节，让使用者只能通过程序规定的方法来访问数据，可以方便地加入存取控制语句，限制不合理操作。
二、继承与多态：
1、继承
继承的定义：
- 子承父，将具有相同行为的类的代码提取为公共类
- 所有描述两个类之间的联系
- 子类/派生类：继承的类
- 父类/基类：被继承的类
//语法
//修饰符 SubClass extends SuperClass{
//类定义部分
}
继承通过extends关键字来实现，其中的SubClass称为子类，SuperClass称为父类、基类或超类，修饰符如果是public，则该类在整个项目中可见，若无public修饰符，则该类只能在当前包可见，不可以使用private和protected修饰类。
public class Pet {
private String name = "无名氏";
private int health = 100;
private int love = 0;
/**
*无参构造方法
*/
public Pet() {
this.health = 95;
System.out.println("执行宠物的无参构造函数！");
}
/**
*有参构造方法
*/
public Pet(String name) {
this.name = name;
}
public String getName() {
return name;
}
public int getHealth() {
return health;
}
public int getLove() {
return love;
}
/**
*输出宠物信息
*/
public void print() {
System.out.println("宠物的自由:\n我的名字叫"+this.name+",健康值是"+this.health+",和主人的亲密度是"+this.love+"。");
}
}
/**
*狗狗类，宠物的子类
*/
public class Dog extends Pet {
private String strain; //品种
public Dog(String name,String strain) {
super(name);//此处不能使用this.name = name;
this.strain = strain;
}
public String getStrain() {
return strain;
}
}
/**
*狗狗类，宠物的子类
*/
public class Penguin extends Pet {
private String sex;//性别
public Penguin(String name,String sex) {
super(name);
this.sex = sex;
}
public String getSex() {
return sex;
}
}
继承是面向对象的三大特性之一，是java中实现代码重用的重要手段之一。
1.1、访问访问修饰符
- 继承public和protected修饰的属性和方法，无论子类和父类是否同一个包里。
- 继承默认权限修饰符的属性和方法，但子类和父类必须在同一个包中。
- 无法继承private修饰的属性和方法。
- 无法继承父类方法
| 访问修饰符 | 本类 | 同包 | 子类 | 其他 |
|---|---|---|---|---|
| private | turn | |||
| 默认 | turn | turn | ||
| protected | turn | turn | turn | |
| public | turn | turn | turn | turn |
2、多态
2.1、重写父类方法
- 相同的方法名
- 相同的参数列表
- 子类不能缩小父类被重写方法的访问权限
- 父类的返回值类型>=子类的返回值类型
- 抛出异常：父类>=子类。
public class Father{
public void SayHi(){
System.out.println("这里是Father父类！");
}
}
public class son extends Father{
@Override
public void SayHi(){
System.out.println("这里是son子类！");
}
}
2.3、instanceof运算符
语法：
//对象 instanceof 类或接口
用于判断对象是否属于用一个类
三、接口
1、语法
访问修饰符 interface 接口名 extends 父接口1,父接口2{
//常量定义
//方法定义
}
class 类名 extends 父类名 implements 接口1，接口2{
//类成员
}
2、接口的特点：
一个类只能有一个直接父类，但可以通过implements实现多个接口。当类在继承父类的同时又实现了多个接口时，extends关键字必须位于implement关键字之前。
3、接口说明：
- 接口中的属性都是全局静态常量，接口中的方法都是全局抽象方法。
- 类只能继承一个父类，但可以实现多个接口。一个类如果实现一个接口，则必须实现接口中的全部方法，否则必须将其定义为抽象类。Java通过实现接口达到多重继承效果。
- 接口表示一种约定，接口也表示一种能力，接口体现了约定和实现分离的原则。