封装概念:在java中通过对象实现数据和指令存储操作,该现象就属于封装行为。
体现方式:
类、对象、属性、方法
- 对象中属性赋值
方式:
1.对象直接赋值
语法: 对象名.属性=值;
2.通过方法赋值
实现方法:
定义一个无返回、有参数方法
//定义一个为属性赋值的方法
public void setFiled(String c,String t,double p) {
color=c;
type=t;
price=p;
}
封装·:通过访问限定符对类,属性,方法,构造方法的可访问范围进行限定,对外提供必要的访问接口。
封装的优点:
(1).良好的封装能够减少耦合。
(2).类内部的结构可以自由修改。
(3).可以对成员变量进行更精确的控制。
(4).隐藏信息,实现细节。
package com.newer.oop;
public class 封装 {
// 定义私有属性
private String name;
private int age;
private char gender;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public static void main(String[] args) {
封装 f=new 封装();
f.setAge(18);
f.setGender('男');
f.setName("张三");
System.out.println(f.getAge());
System.out.println(f.getGender());
System.out.println(f.getName());
}
}
代码运行结果为:
18
男
张三
继承:
子类继承父类的属性和方法。
子类可以重写从父类继承来的属性和方法
子类可以对父类的属性和方法进行扩展
继承的优点:
1 提高了代码的复用性
2 提高了代码的维护性
3 建立了类与类之间的关系,继承是多态的前提。
父类;
package com.newer.oop;
public class Person {
// 定义整形变量
int age;
// 定义一个方法
public void a() {
System.out.println("我是父类的一个方法");
}
}
子类:
package com.newer.oop;
public class Student extends Person {
public static void main(String[] args) {
// 创建Student对象
Student stu=new Student();
// 调用父类的属性
stu.age=15;
// 调用父类的方法
stu.a();
}
}
代码运行后结果为:
我是父类的一个方法
子类重写父类的方法
package com.newer.oop;
public class Student extends Person {
// 重写父类的方法
public void a() {
System.out.println("我是子类重写的一个方法");
}
public static void main(String[] args) {
// 创建Student对象
Student stu=new Student();
// 调用父类的属性
stu.age=15;
// 调用父类的方法
stu.a();
}
}
代码运行后结果为:
我是子类重写的一个方法
重写要注意的事项:
在子类定义一个和父类中同名同参数列表同返回值的方法,访问限定符不能小于父类(同名同参同返回值)
多态:
(1)多种状态,相同类型的对象,调用相同的方法,得到结果可能不一样
(2)静态多态:由于重载机制导致的多态
(3)动态多态:由于重写机制导致的多态
多态就是对同一个对象,在不同时刻表现出来的不同形态
动物类:
package com.newer.oop;
/*
* 动物类
*/
public class Animal {
// 定义一个吃东西的方法
public void eat() {
System.out.println("吃东西");
}
}
狗类:
package com.newer.oop;
//狗类
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃排骨");
}
// 自己独有的方法
public void yao() {
System.out.println("狗咬人");
}
}
兔子类:
package com.newer;
import com.newer.oop.Animal;
//兔子类
public class Rubbit extends Animal {
@Override
public void eat() {
System.out.println("兔子吃胡萝卜");
}
// 自己独有的方法
public void yao() {
System.out.println("兔子不咬人");
}
}
测试类:
package com.newer;
import com.newer.oop.Animal;
import com.newer.oop.Dog;
//测试类
public class Test {
public static void main(String[] args) {
//父类的引用指向子类的实例
Animal a=new Dog();
// 创建狗类对象
Dog d=new Dog();
a.eat();
// 调用狗类里的方法
d.yao();
Animal a1=new Rubbit();
// 创建兔子对象
Rubbit r=new Rubbit();
a1.eat();
r.yao();
}
}
代码运行结果:
狗吃排骨
狗咬人
兔子吃胡萝卜
兔子不咬人
引用转型分类:
- 向上转型
Person p=new Student(); 父类引用指向子类的实例
2.向下转型
Person per2=new Student();
Student stu=(Student)per2;
super 限定符
如果需要在子类方法中调用父类被覆盖的实例方法.
则可以使用 super 限定来调用父类被覆盖的实例方法.
package com.newer.oop;
public class Person {
// 定义整形变量
int age=15;
// 定义一个方法
public void a() {
System.out.println("我是父类的一个方法");
}
}
package com.newer.oop;
public class Student extends Person {
// 重写父类的方法
public void a() {
System.out.println("我是子类重写的一个方法");
}
// 调用父类的属性的方法
public void b() {
System.out.println(super.age);
}
public static void main(String[] args) {
// 创建Student对象
Student stu=new Student();
// 调用父类的属性
stu.age=15;
// 调用父类属性的方法
stu.b();
}
}