Java面向对象-封装、继承、权限修饰符
- 一、封装
- 1、案例1
- 2、案例2
- 二、继承
- 1、案例1
- 2、总结
- 三、多态
- 1、案例
- 四、权限修饰符
- 1、private
- 2、default
- 3、protected
- 4、public
一、封装
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修饰
