Java OPP

一、对象和封装

1、回顾：

1.包名取名规则：字母小写，不能是数字开头

2.类名取名规则：不能是数字开头，首字母大写

2、使用面向对象进行编程设计

面向对象就是抽取过程，可分为三步：

1. 发现类
2. 发现类的属性
3. 发现类的方法

抽象时原则有：

• 属性和方法的设置是发了解决业务问题
• 关注主要属性和方法
• 如没有必要，勿增加额外的类，属性与方法。

遵循以上规则，代码如下：

/*
*宠物狗狗类
*/

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、重写父类方法

1. 相同的方法名
2. 相同的参数列表
3. 子类不能缩小父类被重写方法的访问权限
4. 父类的返回值类型>=子类的返回值类型
5. 抛出异常：父类>=子类。

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通过实现接口达到多重继承效果。
• 接口表示一种约定，接口也表示一种能力，接口体现了约定和实现分离的原则。