一、封装
1、案例1
package com.msp_oop;
public class Girl {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
if(age >= 30){
this.age=18;
}
else{
this.age = age;
}
}
}
package com.msp_oop;
public class Test {
public static void main(String[] args) {
Girl g = new Girl();
// g.age = 18;
// System.out.println(g.age);
g.setAge(50);
System.out.println(g.getAge());
}
}
对于age属性,加了修饰符private,这样外界对它的访问就受到了限制,现在我还想加上其他的限制条件,但是在属性本身没有办法再加了,通过定义方法进行限制条件的添加。
以属性为案例:
进行封装:
1、将属性私有化,被private修饰——》加入权限修饰符;一旦加入了权限修饰符,其他人就不可以随意的获取这个属性。
2、提供public修饰的方法让别人来访问/使用
3、即使外界可以通过方法来访问属性了,但是也不能随意访问,因为咱们方法中加了判断逻辑。
4、实际开发中,方法一般写成setter、getter方法
2、案例2
package com.msp_oop;
public class Student {
private int age;
private String name;
private String sex;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
if ("男".equals(sex) || "女".equals(sex)) {
this.sex = sex;
}
this.sex = "男";
}
//加入构造器
public Student() {
}
public Student(int age, String name, String sex) {
this.name = name;
this.age = age;
// this.sex=sex;
this.setSex(sex);
}
}
package com.msp_oop;
public class Test_Student {
public static void main(String[] args) {
Student st = new Student();
st.setName("kobe");
st.setAge(20);
st.setSex("女");
System.out.println(st.getName()+"---"+st.getAge()+"---"+st.getSex());
Student st1 = new Student(40,"james","男1");
System.out.println(st1.getName()+"---"+st1.getAge()+"---"+st1.getSex());
}
}
二、继承
提高代码的复用性
父类定义的内容,子类可以直接拿过来用就可以了,不用代码上重复定义。
1、案例1
父类
package com.msp_oop1;
public class Person {
//属性
private int age;
private String name;
private double height;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
//方法
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
子类
package com.msp_oop1;
public class Student extends Person{ //todo 子类继承父类
private int sno; //学号
public int getSno() {
return sno;
}
public void setSno(int sno) {
this.sno = sno;
}
//方法
public void study(){
System.out.println("study");
}
}
测试
package com.msp_oop1;
public class Test {
public static void main(String[] args) {
Student st = new Student();
st.setSno(1001);
st.setName("kobe");
st.setAge(18);
System.out.println(st.getName());
System.out.println(st.getAge());
System.out.println(st.getSno());
st.sleep();
}
}
需要注意:
父类private修饰的内容,子类实际上也继承,只是因为封装的特性阻碍了直接调用,但是提供了间接调用的方法,可以间接调用。
2、总结
1、继承关系:父类(基类)/子类(extends)
子类继承父类一定在合理的范围继承
2、好处:
a、提高了代码的复用性
b、便于代码的扩展
c、多态的使用
3、父类private修饰的内容,子类也继承过来了。
4、一个父类可以有多个子类
5、一个子类只能有一个直接父类,但是间接的可以继承其他类
6、继承具有传递性
Student——》继承Person——》继承Object
三、多态
1、现有父类,再有子类,叫继承;现有子类,再抽取父类,叫泛化;
2、什么是多态?
多种状态,同一个行为,不同的子类,表现出不同的形态;
多态指的是同一个方法调用,由于对象不同会产生不同的行为。
3、多态的好处:
提高代码的扩展性,符合面向对象的设计原则,开闭原则。
开闭原则:扩展开发,修改关闭。
4、多态的三个要素:
a、继承:Cat——》Animal;Dog——》Animal
b、重写:play()方法
c、父类引用指向子类对象
Dog dog = new Dog();
Animal animal = dog;
==转化为
Animal animal = new Dog();
girl.play(animal )
public void play(Animal an) {
an.play();
}
上面的代码,也是多态的一种非常常见的应用场合:父类当方法的形参,然后传入的是具体的子类的对象,然后调用同一个方法,根据传入的子类的不同展现的效果也不同,构成了多态。
1、案例
父类
package com.msb_duotai;
public class Animal {
public void play() {
System.out.println("我是小动物,");
}
}
子类
package com.msb_duotai;
public class Cat extends Animal {
public void play() {
System.out.println("和猫玩");
}
}
package com.msb_duotai;
public class Dog extends Animal {
public void play(){
System.out.println("和狗玩");
}
}
儿童类
package com.msb_duotai;
public class Girl {
// public void play(Cat cat){
// cat.play();
// }
//
// public void play(Dog dog){
// dog.play();
// }
//和小动物玩
public void play(Animal an) {
an.play();
}
}
测试类
package com.msb_duotai;
public class Test {
public static void main(String[] args) {
Girl girl = new Girl();
// Cat cat = new Cat();
// girl.play(cat);
//
// Dog dog = new Dog();
// girl.play(dog);
//动物
Cat cat = new Cat();
Dog dog = new Dog();
Animal animal = dog; // TODO: 2024/6/9
girl.play(animal);
}
}
四、权限修饰符
1、private
在当前类中可以访问
2、default
同一个包下的其他类都可以访问
3、protected
权限到不同包下的子类
4、public
在整个项目中都可以访问
总结:
属性、方法,修饰符有四种
private、缺省、protected、public
类修饰符两种:缺省、public
一般属性:用private修饰
一般方法:用public修饰
五、工厂设计模式
定义一个static方法,通过类名直接调用
返回值类型是父类类型,返回的可以是其任意子类类型
传入一个字符串类型的参数,工厂根据参数创建对应的子类产品
package com.msb_duotai;
public class PetStore { //工厂类
public static Animal getAnimal(String petName) { //todo 加上static可以通过类名.方法名去调用
Animal an = null;
if ("猫".equals(petName)) {
an = new Cat();
}
if ("狗".equals(petName)) {
an = new Dog();
}
return an;
}
}
package com.msb_duotai;
public class Dog extends Animal {
public void play() {
System.out.println("和狗玩");
}
}
package com.msb_duotai;
public class Cat extends Animal {
public void play() {
System.out.println("和猫玩");
}
}
package com.msb_duotai;
public class Girl {
//和小动物玩
public void play(Animal an) {
an.play();
}
}
package com.msb_duotai;
public class Test {
public static void main(String[] args) {
Girl girl = new Girl();
Animal an=PetStore.getAnimal("狗");
girl.play(an);
}
}