Java面向对象篇(二)——三大特征

一、面向对象三大特征 ——封装

1.封装

1.1什么是封装？

封装是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

1.2怎么隐藏对象的属性？

想要隐藏对象的属性，只需要在定义属性的前面加上一个关键字private即可实现隐藏。

1.3怎么提供公共的访问方式？

就是在类中写上几个setXXX()和getXXX()，主要为了统一管理。

2.private关键字

2.1什么是private关键字？

是一个修饰符，代表私有的意思，可以修饰成员变量和成员方法和构造方法。

2.2private关键字的特点？

被private修饰的成员变量和成员方法只能在本类中使用，不能在其他类中使用。

2.3标准代码写法？

classPerson{privateString name;//私有变量。//公共访问方式。publicvoidsetName(String n){
                name = n;}publicStringgetName(){return name;}}

3.this关键字

3.1什么是this关键字？

this代表对象的引用，哪个对象调用this所在的方法，this就代表哪个对象。

3.2this关键字有什么用？

1.它可以解决局部变量隐藏成员变量的问题。
2.可以调用本类中的成员变量和成员方法和构造方法。

3.3标准代码写法？

classPerson{privateString name;publicvoidsetName(String name){this.name = name;}publicStringgetName(){returnthis.name;}}

4.构造方法

4.1什么是构造方法？

方法名和类名相同，和普通方法的格式不一样的特殊的方法。

4.2构造方法的定义格式？

//格式：
    修饰符 类名(形参,...){
    执行语句;}publicPerson(){}

4.3构造方法的作用？

1.用来创建对象。
2.用来对象的属性进行初始化。

4.4构造方法的特点？

1.构造方法没有返回值类型。
2.构造方法没有返回值（有renturn，一般不写）。
3.构造方法的名字一定要和类名相同。

4.5构造方法的注意事项？

1.如果我们没有手动写构造方法的话，系统会默认带一个无参构造。
2.如果我们手动写了构造方法的话，系统默认带的无参构造就消失了。
3.构造方法也是方法，既然是方法，就会满足方法的重载，也就说一个类中可以写多个构造方法。

实例

classPerson{//没有手动写构造方法实例publicPerson(){//无参构造}//手动写了构造方法实例以及多个构造方法实例。publicPerson(String name){//有参构造}publicPerson(int age){}publicPerson(String name,int age){}}

4.6一个类中写多个构造方法有什么用呢？

1.可以根据不同的需求来调用不同的构造方法。

实例

classDemo{publicstaticvoidmain(String[] args){//需求：孩子出生时候，没有姓名没有年龄Child c1 =newChild();System.out.println(c1.name +"..."+ c1.age);//null...0//需求：孩子出生时候，有姓名，但是没年龄Child c2 =newChild("张三");System.out.println(c2.name +"..."+ c2.age);//张三...0//需求：孩子出生时候，有姓名，有年龄Child c3 =newChild("李四",18);System.out.println(c3.name +"..."+ c3.age);//哪吒...18}}classChild{String name;int age;//构造一个空参方法。publicChild(){}//三个不同的有参构造方法。publicChild(String name){this.name = name;}publicChild(int age){this.age = age;}publicChild(String name,int age){this.name = name;this.age = age;}}

2.有参的构造方法可以给属性赋值。

实例

classDemo{publicstaticvoidmain(String[] args){//第一种赋值方法Person p =newPerson();
        p.setName("tom");
        p.setAge(18);//第二种赋值方法。Person p =newPerson("tom",18);}}classPerson{privateString name;privateint age;//构造一个空参方法。publicPerson(){}//构造方法应用：publicPerson(String name,int age){this.name = name;this.age = age;}//普通方法应用：publicvoidsetName(String name){this.name = name;}publicvoidsetAge(int age){this.age = age;}publicStringgetName(){returnthis.name;}publicintgetAge(){returnthis.age;}}

4.7通过有参构造给属性赋值和通过setXXX给属性有什么区别呢？

1.setXXX方式赋值可以使用N多次、有参构造方式赋值只能使用一次。
2.有参构造方式是先天的、setXXX方式是后天的。

4.8加上构造方法之后的标准代码怎么写？

classPerson{privateString name;privateint age;//必须构造一个无参方法。publicPerson(){}//构造一个有参方法。publicPerson(String name,int age){this.name = name;this.age = age;}//根据需求构造普通方法。publicvoidsetName(String name){//获取普通方法this.name = name;}publicStringgetName(){//还回值方法。return name;}publicvoidsetAge(int age){this.age = age;}publicintgetAge(){return age;}}

5.static关键字

5.1什么是static关键字？

是一个修饰符，代表静态的意思，它可以修饰成员变量和成员方法，不能修饰构造方法。

5.2static关键字有什么特点？

1.被static所修饰的成员是随着字节码文件对象的加载而加载，所以是优先于对象存在于内存中。
2.被static所修饰的成员被该类下所有的对象所共享。
3.被static所修饰的成员可以通过类名.直接调用。

类名.属性名;
类名.方法名();

5.3static关键字的注意事项？

1.静态方法中不能有this关键字。
2.静态方法中可以调用静态成员变量和静态成员方法，但是不可以调用非静态的成员变量和调用方法。
3. 非静态方法中可以调用静态的成员变量和成员方法，也可以调用非静态的成员变量和成员方法。

实例

packagecom_1;publicclassDemo01{publicstaticvoidmain(String[] args){System.out.println(Person.country);//直接调用静态成员变量Person.eat();//调用静态成员方法。}}classPerson{String name;int age;//修饰静态成员变量country。staticString country;//修饰静态成员方法eat().publicstaticvoideat(){//System.out.println(this);   如果添加这一句就会报错。System.out.println("吃");}}

二、面向对象三大特征 ——继承

1. 什么是继承？

一个类的对象可以使用另一个类的对象中的成员，这种关系就称为继承。

2. 继承的格式？

classA{}classBextendsA{}//类B 继承 类A//类A：父类，超类，基类//类B：子类，派生类

3. 继承的好处是什么？

1.提高了代码的复用性。
2.让类与类之间产生了继承关系，这是构成多态的前提条件。

4. 继承的弊端是什么？

提高了代码的耦合性。
开发原则：高内聚，低耦合。
高内聚：是指这个类的能力越强越好。
低耦合：是指这个类的关系越少越好。

5. 继承的特点？

特点： 在Java中，类只支持单继承，不可以多继承，可以多层继承，不可以循环继承。
实例：

//单继承：classFu{}classZiextendsFu{}//Zi继承Fu。//多层继承：classYe{}classFuextendsYe{}//Fu继承Ye。classZiextendsFu{}//Zi继承Fu。//循环继承：被禁止用，会陷入死循环。classFuextendsZi{}classZiextendsFu{}

6. 继承的注意事项？

1.子类不能继承父类中被private关键字所修饰的成员变量和成员方法。
2.子类不能继承父类中的构造方法。

实例：

classFu{privateString name;//私有的成员变量。int age;publicvoideat(){}privatevoiddrink(){}//私有的成员方法。}classZiextendsFu{publicvoidprint(){System.out.println(name);//编译报错，因为父类的name被私有了System.out.println(age);eat();drink();//编译报错，因为父了drink()被私有了}}

7. 我们在什么时候可以使用继承呢？

当两个类之间存在"is a"的关系的时候，我们就可以使用继承。
实例：

人类 is a 学生类 X  所以人类不能继承学生类
人类 is a 老师类 X  所以人类不能继承老师类

学生类 is a 人类  所以学生类可以继承人类
学生类 is a 老师类 X 所以学生类不能继承老师类

老师类 is a 人类  所以老师类可以继承人类
老师类 is a 学生类 X 所以老师类不能继承学生类

classPerson{}classStudentextendsPerson{}classTeacherextendsPerson{}

8. 在子父类继承中成员变量的关系？

在父类中有一个成员变量，在子类中有一个成员变量，在子类的成员方法中有一个局部变量。

1. 三个变量的名字都不同的实例：

classDemo{publicstaticvoidmain(String[] args){Zi zi =newZi();
        zi.print();//输出结果3、2、1。}}classFu{int i =1;}classZiextendsFu{int j =2;publicvoidprint(){int a =3;System.out.println(a);System.out.println(j);System.out.println(i);}}

1. 三个变量的名字都相同实例：

classDemo{publicstaticvoidmain(String[] args){Zi zi =newZi();
        zi.print();//输出结果：3、3、3。}}classFu{int i =1;}classZiextendsFu{int i =2;publicvoidprint(){int i =3;System.out.println(i);//如果三个变量名都相同，根据相近原则取决i变量。System.out.println(i);System.out.println(i);}}

1. 如何让相同的变量名打印出出不同的值，实例：

classDemo{publicstaticvoidmain(String[] args){Zi zi =newZi();
        zi.print();//输出结果：3、2、1.}}classFu{int i =1;}classZiextendsFu{int i =2;publicvoidprint(){int i =3;System.out.println(i);//输出本结构变量值。System.out.println(this.i);//this输出本类的变量值。System.out.println(super.i);//super输出父类的变量值。}}

9. 在子父类继承中构造方法的关系？

1.子类在中的所有的构造方法的第一行，默认都有一个super()。

classDemo{publicstaticvoidmain(String[] args){Zi zi =newZi();System.out.pintln(zi.name);//null}}classFu{String name;publicFu(){}}classZiextendsFu{publicZi(){//super();//调用父类的空参构造}publicZi(int age){//super();//调用父类的空参构造}}

2.子类中的所有的构造方法中，第一行要么是super(参数)，要么是this(参数)，他们不可以共存。
3.子类中所有的构造方法中至少有一个构造方法里面调用的是super(参数)。

classDemo{publicstaticvoidmain(String[] args){Zi zi =newZi();}}classFu{}classZiextendsFu{publicZi(){this("aaa");//调用下面的方法。}publicZi(String name){this(18);//调用下面的方法。}publicZi(int age){this("aaa",18);//调用下面的方法。}publicZi(String name,int age){//super();  //调用父类的方法。}}

10. 在子父类继承中成员方法的关系？

在父类中有一个成员方法，在子类中有一个成员方法。

1. 如果这两个方法的名字都不同的实例：

classDemo{publicstaticvoidmain(String[] args){Zi zi =newZi();
        zi.printFu();//输出结果：fu...
        zi.printZi();//输出结果：zi...}}classFu{publicvoidprintFu(){System.out.println("fu...");}}classZiextendsFu{publicvoidprintZi(){System.out.println("zi...");}}

1. 如果这两个方法的名字都相同的实例：

package 继承;publicclassDom2{publicstaticvoidmain(String[] args){
        msli li =newmsli();
        li.println();}}//子类的方法的访问权限修饰符要大于等于父类的方法的访问权限修饰符,public > protected > 默认 > private。class msliu
{publicvoidprintln(){System.out.println("123");}}class msli extends msliu
{@Override//证明该方法是重写方法。publicvoidprintln(){System.out.println("456");}}//输出结果：456

11. 重写

1. 什么是方法的重写(Override)呢？

• 在子父类继承中，子类中出现与父类方法的声明完全一致的方法，就称为方法的重写(大致意思)。

2.方法的重写(Overide)和方法的重载(Overload)的区别？

• 重载：在同一个类，两个方法的名字相同，参数列表不同。
• 重写：在子父类继承中，子类中的方法和父类中方法是完全一致。

3.我们怎么证明该方法是重写方法呢？

• 只需要在方法的声明上面加上@Override，参照以上实例。

4.重写的注意事项？

• 1.子类不能重写父类中的私有的成员方法。
• 2.子类的方法的访问权限修饰符要大于等于父类的方法的访问权限修饰符，参照以上实例。
• 3.子类的方法的返回值类型可以和父类重写方法的返回值类不一致的， 但是有条件，父类方法的返回值类型是子类方法的返回值类型的父类。

//子类的方法的返回值类型可以和父类重写方法的返回值类不一致的,但是有条件，父类方法的返回值类型是子类方法的返回值类型的父类.class msw
{public msu print(){returnnewmsu();}}class mse extends msw
{public msn print(){returnnewmsn();}}class msu{}class msn extends msu{}

• 4.静态方法只能重写静态方法。

三、面向对象三大特征 ——多态

1. 什么是多态？

是指一个对象在不同的时刻，表现出来的不同的状态。

2. 多态的前提条件？

• 1.要有继承关系。
• 2.要有方法的重写(可以没有)。
• 3.要有父类引用指向子类对象。

3. 多态的代码体现？

classFu{publicvoidprint(){}}classZiextendsFu{//有继承关系publicvoidprint(){//有方法重写}}classDemo{publicstaticvoidmain(String[] args){Fu fu =newZi();//父类引用指向子类对象}}

4. 多态间子父类之间成员变量的关系？

父类中有一个成员变量，子类中有一个成员变量。

• 如果这两个变量的名字不同的话：

classDemo{publicstaticvoidmain(String[] args){Fu fu =newZi();System.out.println(fu.i);//1System.out.println(fu.j);//编译报错}}classFu{int i =1;}classZiextendsFu{int j =2;}

分析： 通过结果分析，父类引用不能使用子类中特有的成员变量。

• 如果这两个方法的名字都相同的话：

classDemo{publicstaticvoidmain(String[] args){Fu fu =newZi();System.out.println(fu.i);//1System.out.println(fu.i);//1}}classFu{int i =1;}classZiextendsFu{int i =2;}

分析： 父类引用只能使用自身带的成员变量，不能使用子类中成员变量。

口诀：多态，调用成员变量的时候，编译看左边，运行看左边。

5. 多态间子父类之间成员方法的关系？

父类中有一个成员方法，子类中有一个成员方法。

• 如果这两个方法的名字都不同的话：

classFu{publicvoidprintFu(){System.out.println("fu");}}classZiextendsFu{publicvoidprintZi(){System.out.println("zi");}}classDemo{publicstaticvoidmain(String[] args){Fu fu =newZi();
        fu.printFu();//fu
        fu.printZi();//编译报错}}

分析： 父类引用不能使用子类中特有的成员方法。

• 如果这两个方法的名字都相同的话：

classFu{publicvoidprint(){System.out.println("fu");}}classZiextendsFu{publicvoidprint(){System.out.println("zi");}}classDemo{publicstaticvoidmain(String[] args){Fu fu =newZi();
        fu.print();//zi
        fu.print();//zi}}

分析： 父类引用可以使用子类中重写父类的方法。

口诀：多态，调用成员方法，编译看左边，运行看右边。

6. 多态间子父类在之间静态成员的关系？

6.1 静态成员变量：

classFu{staticint i =1;}classZiextendsFu{staticint j =2;}classDemo{publicstaticvoidmain(String[] args){Fu fu =newZi();System.out.println(fu.i);// 1System.out.println(fu.j);//编译报错}}

6.2 静态成员方法：

classFu{publicstaticvoidprint(){System.out.println("fu");}}classZiextendsFu{publicstaticvoidprint(){System.out.println("zi");}}classDemo{publicstaticvoidmain(String[] args){Fu fu =newZi();
        fu.print();//fu}}

6.3 总结：

多态，静态，成员变量和成员方法，编译看左边，运行看看左边。

7.多态的好处？

1. 提高了代码的扩展性。
2. 父类引用作为形式参数，子类对象作为实际参数。

publicclassDemo02{publicstaticvoidmain(String[] args){AnimalTool.print(newCat());AnimalTool.print(newDog());AnimalTool.print(newPig());}}//动物工具类classAnimalTool{publicstaticvoidprint(Animal animal)//Animal animal = new Dog/Cat/Pig(),重新定义{
        animal.eat();//动物相应的值。}}classAnimal{publicvoideat(){}}classDogextendsAnimal{publicvoideat(){System.out.println("吃骨头");}}classCatextendsAnimal{publicvoideat(){System.out.println("吃鱼");}}classPigextendsAnimal{publicvoideat(){System.out.println("吃白菜");}}

8.多态的弊端？

父类引用不能使用子类中特有的内容。

怎么解决？

• 向下转型来解决这个问题。

何为转型？

• 向上转型：Fu fu = new Zi();
• 向下转换：Zi zi = (Zi)fu;

代码实例：

publicclass txt {publicstaticvoidmain(String[] args){//向上转型Fu fu =newZi();
        fu.eat();//吃肉//向下转型Zi zi =(Zi)fu;
        zi.play();//玩游戏
        zi.eat();//吃肉}}classFu{publicvoideat(){System.out.println("吃饭");}}classZiextendsFu{publicvoideat(){System.out.println("吃肉");}publicvoidplay(){System.out.println("玩游戏");}}

总结：面向对象的三大特征已经讲完啦，欢迎小伙伴们前来评论呢？