一、封装:
封装的概念:
- 合理的隐藏:隐藏不想被外界操作的Field、方法、构造器
- 合理的暴露:一般就是希望给别人调用的方法
e.g:显示器(按键暴露出来操作,但实际的东西/细节方法被隐藏起来)
封装的目的：
- 简化编程(不去去找显示器的内部调,直接按键调整即可)
- 更好的保证对象的完整性
为了实现隐藏，我们有4个修饰符：
private - 仅限当前类访问权限
无修饰符/默认 - 包访问权限(同一个包内)
protected - 子类访问权限(本类能访问、同一个包也能访问)
public - 公共的访问权限
权限级别:private → 默认访问权限 → protected → public (只有成员变量才需用访问权限修饰符)
private - 用于隐藏Field
public - 专门用于暴露方法
protected - 希望被它的子类访问的方法
默认 - 希望在同一个包中被访问
局部变量方法一执行完就销毁了,所以没必要限制,限制了也没意义,它尽在方法内或代码块中有效,作用域本来就小-连方法都出不了,所以它用访问权限修饰符都是多余(默认都多余)
class Fruit {
private double weight;
private String name;
public void grow(double grow){
if(this.weight + grow >= 100){
System.out.println("水果超出重量,逆天了！");
}else{
weight = weight + grow;
}
}
public void setName(String name){
if(name.length() > 6 || name.length() < 2){
System.out.println("水果名字不符合规则");
}else{
this.name = name;
}
}
public void info(){
System.out.println("这个是:" + name + ",重量为:" + weight);
}
}
class TestFruit{
public static void main(String[] args){
Fruit t = new Fruit();
//t.weight = 200; 定义为private后不能直接赋值
//t.name = "Apple"; 如果直接赋值将破坏Fruit对象的数据完整性
t.grow(10);
//t.grow(101); //不符合定义规则打印对应语句
//t.setName("A");
t.setName("Apple");
t.info();
}
}
二、继承:(extends)
Java的继承 - 两个类之间的关系(A extends B),Java中的继承从"一般到特殊"的关系,如:
人 → 老师 → IT老师 → 教Java的老师
Java通过关键字extends来实现，实现继承的类称为子类,被继承的类称为基类/超类/父类，父类是大类(范围大)，子类是小类
Java的继承是单继承，每个继承类(extends后面)只能有一个直接父类但可以有N个间接父类,子类继承了父类 仅【能】获得父类的全部属性和方法但【不能】获得父类的构造器、初始化块、内部类
如果定义的Java类没有显示的指定父类,系统默认会让它继承Object类--一切的类都是Object类的子类
public class Person {
private String name;
private int age;
public Person(){} //父类空构造器,子类初始化是会报错
public Person(String name , int age){
this.name = name;
this.age = age;
}
public void info(){
System.out.println("这人叫:" + name + ",年龄是:" + age);
}
public static void main(String[] args) {
Person p = new Person("小二",20);
p.info();
}
}
public class Teacher extends Person{
public static void main(String[] args){
//子类将会从父类那里获取到所有方法
Teacher t = new Teacher();
//调用从父类那里继承到的方法
t.info();
}
}
继承中父类与子类的关系是"一般到特殊的关系",所以子类的实例完全可以当作父类的对象来使用,父类的引用变量完全可以指向子类的实例。
class Animal{
private String name;
private String sex;
public Animal(String name , String sex){
this.name = name;
this.sex = sex;
}
public void info(){
System.out.println("动物的名字叫:" + name + ",性别为:" + sex);
}
}
public class TestAnimal extends Animal{
private String color;
public TestAnimal(String name , String sex , String color){
super(name,sex);
this.color = color;
}
public static void test(Animal A){
System.out.println("~这是个测试方法~");
A.info();
}
public static void main(String[] args){
Animal ta = new TestAnimal("灰太狼","male","灰色");
TestAnimal.test(ta);
}
}
三、多态：
同一类型的变量,在访问同一方法时, 呈现出多种行为特征 -- 这就是多态。
多态增加了Java语言的灵活性,它是和设计模式紧密相连的。
class Person{
public void work(){
System.out.println("努力工作！");
}
}
class Teacher extends Person{
@Override
public void work(){
System.out.println("辛勤的教书！");
}
}
class Student extends Person{
@Override
public void work(){
System.out.println("努力的读书！");
}
public void play(){
System.out.println("读书真累啊！");
System.out.println("累的时候也要适当的玩耍啊！");
}
}
public class Duotai{
public static void main(String[] args) {
//多态:同一个类型的变量在访问同一个方法时,表现出多种行为特征
//p、p1、p2均为person类型变量,但在访问work方法时返回的结果都不一样则为多态
Person p = new Person();
p.work();
//子类的实例/对象完全可以当成父类的对象来使用
//p1引用变量指向Teacher实例
Person p1 = new Teacher();
p1.work();
Person p2 = new Student();
p2.work();
//编译阶段不管运行时类型的,编译器并不知道引用变量实际引用的对象时Student,编译器只知道它的编译时类型为Person,而Person又没有play()方法,所以编译报错
//p2.play();
//若要调用play()方法,则可以使用Student来定义变量,或者使用强制转换将p2转换成student对象
Student st = (Student)p2;
st.play();
Student p3 = new Student();
p3.play();
}
}
Java的引用变量有两个类型:
1、编译时类型:由声明它的类型来决定所以p、p1、p2的编译类型均为Person,p3的编译类型为Student；
2、运行时类型:由该引用变量实际所指向的对象决定p的为Person,p1 为Teacher, p2为Student,p3为Student,当我们调用引用变量时,它总是呈现它的运行时的特征.