一、封装与隐藏
package com.atguigu.java;
/*
* 面向对象的特征一：封装与隐藏 3W:what? why? how?
* 一、问题的引入：
* 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到
* 属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值
* 加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
* 同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
* -->此时，针对于属性就体现了封装性。
*
* 二、封装性的体现：
* 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
*
* 拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 ...
*
*
* 三、封装性的体现，需要权限修饰符来配合。
* 1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
* 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
* 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
* 修饰类的话，只能使用：缺省、public
*
* 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
*
*/
public class AnimalTest {
public static void main(String[] args) {
Animal a = new Animal();
a.name = "大黄";
// a.age = 1;
// a.legs = 4;//The field Animal.legs is not visible
a.show();
// a.legs = -4;
// a.setLegs(6);
a.setLegs(-6);
// a.legs = -4;//The field Animal.legs is not visible
a.show();
System.out.println(a.name);
}
}
class Animal{
String name;
private int age;
private int legs;//腿的个数
//对属性的设置
public void setLegs(int l){
if(l >= 0 && l % 2 == 0){
legs = l;
}else{
legs = 0;
// 抛出一个异常（暂时没有讲）
}
}
//对属性的获取
public int getLegs(){
return legs;
}
public void eat(){
System.out.println("动物进食");
}
public void show(){
System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
}
//提供关于属性age的get和set方法
public int getAge(){
return age;
}
public void setAge(int a){
age = a;
}
}
//private class Dog{
//
//}
package com.atguigu.java;
public class Order {
private int orderPrivate;
int orderDefault;
public int orderPublic;
private void methodPrivate(){
orderPrivate = 1;
orderDefault = 2;
orderPublic = 3;
}
void methodDefault(){
orderPrivate = 1;
orderDefault = 2;
orderPublic = 3;
}
public void methodPublic(){
orderPrivate = 1;
orderDefault = 2;
orderPublic = 3;
}
}
package com.atguigu.java;
public class OrderTest {
public static void main(String[] args) {
Order order = new Order();
order.orderDefault = 1;
order.orderPublic = 2;
//出了Order类之后，私有的结构就不可以调用了
// order.orderPrivate = 3;//The field Order.orderPrivate is not visible
order.methodDefault();
order.methodPublic();
//出了Order类之后，私有的结构就不可以调用了
// order.methodPrivate();//The method methodPrivate() from the type Order is not visible
}
}二、面向对象的特征之二：继承性
package com.atguigu.java;
/*
* 面向对象的特征之二：继承性 why?
*
* 一、继承性的好处：
* ① 减少了代码的冗余，提高了代码的复用性
* ② 便于功能的扩展
* ③ 为之后多态性的使用，提供了前提
*
*
* 二、继承性的格式：
* class A extends B{}
* A:子类、派生类、subclass
* B:父类、超类、基类、superclass
*
* 2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
* 特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
* 只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
* 2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
* 子类和父类的关系，不同于子集和集合的关系。
* extends：延展、扩展
*
* 三、Java中关于继承性的规定：
* 1.一个类可以被多个子类继承。
* 2.Java中类的单继承性：一个类只能有一个父类
* 3.子父类是相对的概念。
* 4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
* 5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
*
*
* 四、 1. 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
* 2. 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
* 3. 意味着，所有的java类具有java.lang.Object类声明的功能。
*/
public class ExtendsTest {
public static void main(String[] args) {
Person p1 = new Person();
// p1.age = 1;
p1.eat();
System.out.println("*****************");
Student s1 = new Student();
s1.eat();
// s1.sleep();
s1.name = "Tom";
s1.setAge(10);
System.out.println(s1.getAge());
s1.breath();
Creature c = new Creature();
System.out.println(c.toString());
}
}
三、面向对象特征之三：多态性
package com.atguigu.java;
import java.util.Date;
/*
* 面向对象特征之三：多态性
*
* 1.理解多态性：可以理解为一个事物的多种形态。
* 2.何为多态性：
* 对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
*
* 3. 多态的使用：虚拟方法调用
* 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
* 总结：编译，看左边；运行，看右边。
*
* 4.多态性的使用前提： ① 类的继承关系 ② 方法的重写
*
* 5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
*
* *************************************************************
*
*
*/
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.eat();
Man man = new Man();
man.eat();
man.age = 25;
man.earnMoney();
//*************************************************
System.out.println("*******************");
//对象的多态性：父类的引用指向子类的对象
Person p2 = new Man();
// Person p3 = new Woman();
//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
p2.eat();
p2.walk();
// p2.earnMoney();
System.out.println(p2.id);//1001
System.out.println("****************************");
//不能调用子类所特有的方法、属性：编译时，p2是Person类型。
p2.name = "Tom";
// p2.earnMoney();
// p2.isSmoking = true;
//有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致
//编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
//如何才能调用子类特有的属性和方法？
//向下转型：使用强制类型转换符。
Man m1 = (Man)p2;
m1.earnMoney();
m1.isSmoking = true;
//使用强转时，可能出现ClassCastException的异常。
// Woman w1 = (Woman)p2;
// w1.goShopping();
/*
* instanceof关键字的使用
*
* a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
*
*
* 使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
* 进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
*
* 如果 a instanceof A返回true,则 a instanceof B也返回true.
* 其中，类B是类A的父类。
*/
if(p2 instanceof Woman){
Woman w1 = (Woman)p2;
w1.goShopping();
System.out.println("******Woman******");
}
if(p2 instanceof Man){
Man m2 = (Man)p2;
m2.earnMoney();
System.out.println("******Man******");
}
if(p2 instanceof Person){
System.out.println("******Person******");
}
if(p2 instanceof Object){
System.out.println("******Object******");
}
// if(p2 instanceof String){
//
// }
//练习：
//问题一：编译时通过，运行时不通过
//举例一：
// Person p3 = new Woman();
// Man m3 = (Man)p3;
//举例二：
// Person p4 = new Person();
// Man m4 = (Man)p4;
//问题二：编译通过，运行时也通过
// Object obj = new Woman();
// Person p = (Person)obj;
//问题三：编译不通过
// Man m5 = new Woman();
// String str = new Date();
// Object o = new Date();
// String str1 = (String)o;
}
}
//class Order{
//
//}
原文地址：https://www.cnblogs.com/xingqisan/p/12114266.html
时间： 2024-10-12 01:39:23