面向对象的三大特征
java面向对象的三大特征:“封装”，“继承”,“多态”
一、封装
1.概念
将类的某些特征隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。1.好处
a.只能通过规定的方法访问数据；
b.隐藏类的实现细节，方便修改和实现；
c.高内聚，低耦合。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。3.封装的实现步骤
a.修改属性的可见性(设为private)；
b.创建getter/setter方法（用于属性的读写）；
c.在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）。
下面看列子：
1.1、java中的访问修饰符
访问修饰符的总结：
| 访问修饰符 | 本类 | 同包 | 子类 | 其他 |
|---|---|---|---|---|
| private | √ | |||
| 默认 | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
1.2、java中的this关键字
1.this关键字代表当前对象
this.属性 操作当前对象的属性
this.方法 操作当前对象的方法2.封装对象的属性的时候，经常会使用this关键字。
3.普通方法中：this总是指向调用该方法的对象；
构造方法中：this总是指向正要初始化的对象。
1.3、java中的内部类
1.内部类
- 一般情况下，把类定义成独立的单元；有些情况下，把一个类定义在另一个类的内部，即内部类。
- 2.内部类的作用：
提供了更好的封装。只能让外部类直接访问，不允许同一个包的其他类直接访问；内部类可以直接访问外部类的私有属性，内部类被当成外部类的成员。但外部类不能访问内部类的内部属性。
练习
//外部类的私有属性name
private String name = "liqi";
//外部类的成员属性
int age = 20;
//成员内部类Inner
public class Inner {
String name = "李起起";
//内部类中的方法
public void show() {
System.out.println("外部类中的name：" + aaa.this.name);
System.out.println("内部类中的name：" + name);
System.out.println("外部类中的age：" + age);
}
}
public static void main(String[] args) {
//创建外部类的对象
aaa o = new aaa ();
//创建内部类的对象
Inner inn = o.new Inner();
//调用内部类对象的show方法
inn.show();
}
程序运行结果：
外部类中的name：liqi
内部类中的name：李起起
外部类中的age：20
java中的静态内部类
静态内部类是用static修饰的内部类，特点：
1、静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 ；
2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员；
3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类()。
程序运行结果
访问外部类中的b：1
访问内部类中的b：2
练习：
//外部类
public class HelloWorld {
// 外部类中的静态变量score
private static int score = 84;
// 创建静态内部类
public static class SInner {
// 内部类中的变量score
int score = 91;
public void show() {
System.out.println("访问外部类中的score：" + HelloWorld.score);
System.out.println("访问内部类中的score：" + score);
}
}
// 测试静态内部类
public static void main(String[] args) {
// 直接创建内部类的对象
SInner si = new SInner();
// 调用show方法
si.show();
}
}
程序运行结果
访问外部类中的score：84
访问内部类中的score：91
java中的方法内部类
- 方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
- 注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
练习：
//外部类
public class HelloWorld {
private String name = "jfy";
// 外部类中的show方法
public void show() {
// 定义方法内部类
class MInner {
int score = 83;
public int getScore() {
return score + 10;
}
}
// 创建方法内部类的对象
MInner mi = new MInner();
// 调用内部类的方法
int newScore=mi.getScore();
System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);
}
// 测试方法内部类
public static void main(String[] args) {
// 创建外部类的对象
HelloWorld mo = new HelloWorld();
// 调用外部类的方法
mo.show();
}
}
运行结果
姓名：jfy
加分后的成绩：93
二、继承
- 类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。
- 提高代码的复用性。
- 子类继承父类，可以得到父类的全部属性和方法（除了父类中的构造方法）。
- java中只有单继承，没有像c++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。
- java中的多继承可以通过接口来实现。
列子：
public class Animal {
public int age;
public String name;
public void eat(){
System.out.println("动物吃吃吃！");
}
}
----------
public class Dog extends Animal {
}
----------
public class Initail {
public static void main(String[] args) {
// TODO Auto-generated method stub
Dog dog=new Dog();
dog.age=10;
dog.name="小狗";
dog.eat();
System.out.println(dog.age);
System.out.println(dog.name);
}
}
方法重写：
如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。
重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。
重写方法不能使用比被重写方法更严格的访问权限（由于多态）。
继承的初始化顺序
先初始化父类再初始化子类；
先执行初始化对象中的属性，再执行构造方法中的初始化。
例子：
public class Animal {
public int age=10;
public String name;
public void eat(){
System.out.println("动物具有吃东西的能力！");
}
public Animal(){
System.out.println("Animal父类构造器执行了！");
age=20;
}
}
----------
public class Dog extends Animal {
public Dog(){
System.out.println("Dog子类构造器执行了！");
}
}
----------
public class Initail {
public static void main(String[] args) {
// TODO Auto-generated method stub
Animal an=new Animal();
System.out.println("animal age:"+an.age);
Dog dog=new Dog();
dog.age=10;
dog.name="小狗";
dog.eat();
}
}
程序运行结果：
Animal父类构造器执行了！
animal age:20
Animal父类构造器执行了！
Dog子类构造器执行了！
动物具有吃东西的能力！
java中的final关键字的使用
- final关键字做标识有“最终的”含义。
- final可以修饰类、方法、属性和变量。
1.修饰类：则该类不允许被继承；
2.修饰方法：则该方法不允许被覆盖（重写）；
3.修饰属性：则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值；
4.修饰变量：则该变量的值只能赋一次值，即为常量。
Java中的super关键字的使用
super关键字：在对象的内部使用，可以代表父类对象。
1.访问父类的属性：
super.age
2.访问父类的方法：
super.eat（）super的应用
1.子类的构造过程当中必须调用其父类的构造方法。
2.如果子类的构造方法当中没有显示调用父类的构造方法，则系统会默认调用父类无参的构造方法（通过super关键字）。
3.如果显示的调用构造方法，必须写在子类的构造方法的第一行（super（）；）。
4.如果子类构造方法中既没有显示调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。
java中的Object类
LObject类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。Object类中的方法，适合所有子类。
几个重要的方法
1.toString（）方法：
在Object类中定义toString（）方法的时候，返回的是对象的哈希code码（对象地址字符串）。
可以通过重写toString（）方法表示出对象的属性。
2.equals（）方法：
比较的是对象的引用是否指向同一块内存地址。
三、多态
多态：对象的多种形态。多态是oop中的一个重要特性，主要是用来实现动态联编的，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。
- 引用变量的两种类型：
1.编译时类型：模糊一点，一般是一个父类；由声明时的类型决定。
2.运行时类型：运行时，具体是那个子类就是哪个子类；由实际对应的对象类型决定。 - 多态类型：
1.引用多态：
a.父类的引用可以指向本类的对象。
b.父类的引用可以指向子类的对象。
2.方法多态：
a.创建本类对象时，调用的方法为本类方法。
b.创建子类对象时，调用的方法为子类重写的方法或者继承的方法。
例子：
public class Animal {
public void eat(){
System.out.println("动物具有吃的能力");
}
}
----------
public class Dog extends Animal {
public void eat(){
System.out.println("狗是吃肉的");
}
public void watchDoor(){
System.out.println("狗具有看门的能力");
}
}
----------
public class Cat extends Animal {
}
----------
public class Initail {
public static void main(String[] args) {
// TODO Auto-generated method stub
Animal obj1 = new Animal();
Animal obj2 = new Dog();//父类的引用是可以指向子类对象的
Animal obj3 = new Cat();
//Dog obj3 = new Animal();//错
obj1.eat();//
obj2.eat();/
obj3.eat();
//obj2.watchDog();//watchDog()是子类独有的方法，并不是从父类继承来的，此时在main函数中就不能通过父类的引用调用子类独有的方法。
}
}
程序运行结果
动物具有吃的能力
狗是吃肉的
动物具有吃的能力
