一.封装
1.概念
?? 封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。
2.封装原则
??将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法
3.封装好处
??1.通过方法来控制成员变量的操作，提高了代码的安全性
??2.把代码用方法进行封装，提高了代码的复用性
??3.类内部的结构可以自由修改。隐藏信息，实现细节。
4.权限修饰符
??当我们在一个类中定义成员变量时，会指定一个变量的类型，除此之外，还会有修饰符的部分，在此给出定义成员变量的规范格式：
| // 定义变量 1.[修饰符] 变量类型 变量名称; 2.[修饰符] 变量类型 变量名称 = 初始值; |
5.封装代码
```java
代码演示：
/*学生类*/
public class Student {
private int number;//private修饰三个属性
private int state;
private int score;
public Student (){
}//无参构造器
public Student(int number,int state,int score){
this.number=number;
this.state=state;
this.score=score;
}//有参构造器
/*下面是Student类提供的get() set()方法外界可以通过他们访问！*/
public void setNumber(int number){
this.number=number;
}
public int getNumber(){
return number;
}
public void setState(int state){
this.state=state;
}
public int getState(){
return state;
}
public void setScore(int score){
this.score=score;
}
public int getScore(){
return score;
}
}
===============================
/*测试类*？
public class StudentDemo {
public static void main(String[] args) {
//无参构造方法创建对象后使用setXxx()赋值
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(30);
s1.show();
//使用带参构造方法直接创建带有属性值的对象
Student s2 = new Student("林青霞",30);
s2.show();
}
}
二.继承
1.概述
??继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
2.继承优点
1.继承过来的字段和方法，可以像任何其他字段和方法一样被直接使用；
2.在子类中可以声明一个与父类中同名的新字段或静态方法，从而“隐藏”父类中的字段或方法；
3.可以在子类中声明一个在父类中没有的新字段和方法；
4.可以在子类中编写一个父类当中具有相同名的新实例方法，这称为“方法重写”或“方法覆盖”；
5.可以在子类中编写一个调用父类构造方法的子类构造方法，既可以隐式地实现，也可以通过使用关键字super来实现。
3.变量访问特点
| 在子类方法中访问一个变量，采用的是就近原则。 |
- 子类局部范围找
- 子类成员范围找
- 父类成员范围找
- 如果都没有就报错(不考虑父亲的父亲…)
4.代码演示
//代码演示：
class teacher{ //声明一个teacher类为父类
String name; //定义父类的成员变量name、age
int age;
void show(){ //定义父类成员方法，将成员变量输出
System.out.println(name);
System.out.println(age);
}
}
class Student extends teacher { //声明一个Student类为子类并继承父类
}
public class myfirst {
public static void main(String[] args) {
System.out.println("学生");
Student student=new Student(); //声明一个Student类的实例对象student
student.name="Tom"; //子类调用父类的成员变量name并赋值
student.age=19; //子类调用父类的成员变量age并赋值
student.show(); //子类调用父类的成员方法show
}
}
5.继承中的关键字
1、 extends关键字
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
2、implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
public class C implements A,B {
}
3、super 与 this 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类
this关键字：指向自己的引用。
4、final关键字
- fianl关键字的作用
- final代表最终的意思，可以修饰成员方法，成员变量，类
- final修饰类、方法、变量的效果
- fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
- final修饰方法：该方法不能被重写
- final修饰变量：表明该变量是一个常量，不能再次赋值
final不能修饰构造器
final与static搭配使用不会导致类加载
Final拓展：
5.static关键字
static的访问特点
- 非静态的成员方法
- 能访问静态的成员变量
- 能访问非静态的成员变量
- 能访问静态的成员方法
- 能访问非静态的成员方法
- 静态的成员方法
- 能访问静态的成员变量
- 能访问静态的成员方法
- 总结成一句话就是：
- 静态成员方法只能访问静态成员
6.继承的注意事项
Java中继承的注意事项
- Java中类只支持单继承，不支持多继承
错误范例：class A extends B, C { } - Java中类支持多层继承
7.重写
- 方法重写的注意事项
- 私有方法不能被重写(父类私有成员子类是不能继承的)
- 子类方法访问权限不能更低(public > 默认 > 私有)
3.代码实现
代码：
public class InheritenceTest {
public static void main(String[] args) {
Dog dog = new Dog();
dog.run();
}
}
class Animal {
public void run() {
System.out.println("animal is running");
}
}
class Dog extends Animal {
public void run() {
System.out.println("Dog is running");
super.run();//调用父类的run方法
}
}
}// 方法重写与方法重载之间的关系：重载发生在同一个类内部的两个方法或多个方法。重写发生在父类和子类之间。
三.多态
1.多态概述
-
什么是多态
? 同一个对象，在不同时刻表现出来的不同形态
-
多态的前提
- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象
2.代码演示
代码：
/*接口类*/
public interface Jumpping {
void Jump();
}
/*测试类*/
public class AnimalDemo {
public static void main(String[] args) {
Jumpping j=new Cat();//父类引用指向子类也叫向上转型
j.Jump();
}
}
3.成员访问特点
成员访问特点
-
成员变量
? 编译看父类，运行看父类
-
成员方法
? 编译看父类，运行看子类
4.多态的转型
-
向上转型
? 父类引用指向子类对象就是向上转型
例子：Animal a=new Cat() -
向下转型
? 格式：子类型 对象名 = (子类型)父类引用;
例子：Cat c=(Cat) Animal
5.多态的好处与弊端
-
好处
? 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
-
弊端
? 不能使用子类的特有成员