封装概念：在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();
}
}
