------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
在Java的开发过程，其实就是不断的创建对象，使用对象，指挥对象做事情。设计的过程，其实就是在管理和维护对象之间的关系。
面向对象的三个特征：1、封装；2、继承；3、多态.
一、创建一个类（对象）
使用面向对象编程思想在java程序中,表示出一辆汽车
对象->汽车.
java程序需要一辆汽车:
用面向对象思想考虑汽车,一辆汽车就是一个对象...
如何用java 代码表示一个对象...
程序设计者: 先设计这个汽车...
设计汽车:
自然语言设计.
汽车:
属性
颜色
名字
价格
型号
行为
跑...
java 代码设计出一辆汽车,并创建出这辆汽车对象.
在java 代码中如何设计一个汽车,是通过类(class 进行)
java 语言设计汽车...
class Car{
变量->属性
方法->行为(功能)
}
1 public class Demo{
2 public static void main(String[] args){
3 //2. 根据设计好的Car 类,创建汽车对象了.
4 Car c=new Car();
5 // 给对象的属性赋值.
6 c.name="宝马";
7 c.color="白色";
8 c.type="x6";
9 c.price=1000000;
10 //使用对象. 可以让这辆车运行...
11 c.run();
12 // 获取对象的属性值.
13 System.out.println("价格:"+c.price);
14 }
15 }
16 /**
17 1.设计汽车类.
18 有汽车类,可以根据汽车类创建出对应的汽车对象...
19 */
20 class Car{
21 //属性-> 成员变量(直接位于类中,是类的成员一部分)
22 String name;
23 String color;
24 String type;
25 double price;
26 //行为 ->成员方法(直接位于类中,是类的成员的一部分)
27 public void run(){
28 System.out.println(color+"的"+name+" "+type+"价值:"+price+"在跑.");
29 }
30 }
二、封装
1. 实现方式:
成员变量私有
使用private 修饰成员变量.
访问修饰符,保证成员变量被private 修饰后,只能在本类中访问,离开本类就无法访问了...
提供公共的get和set 方法.
get 方法获取对象的属性值
set 方法使用给对象的属性赋值.
在set 方法可以加入逻辑判断,过滤掉非法数据.
根据实际开发,可以控制set 和set ,如果不能对外提供的方法,就不可以不提供get 或者set ...
类的封装的好处:
隐藏了类的具体实现
提高对象数据(对象属性)的安全性
提高了程序的可维护性和安全性
1 public class Demo1{
2 public static void main(String[] args){
3 Person p=new Person();
4 p.name="tom";
5 p.age=22;
6 }
7 }
8 class Person{
9 private String name;
10 private int age;
11
12 public void setName(String n){
13 name=n;
14 }
15 public void setAge(int a){
16 if(a>0&&a<=130){
17 age=a;
18 }else{ // 过滤非法数据...
19 System.out.println("年龄非法!!!");
20 }
21 }
22 public String getName(){
23 return name;
24 }
25 public int getAge(){
26 return age;
27 }
28
29 public void speak(){
30 System.out.println("姓名:"+name+" 年龄:"+age+"我会说话.");
31 }
32 }
三、继承
继承是子类复制了父类除被private修饰之外的成员属性和成员方法.同时在这个基础上对属性和方法进行增删查改.
1 class Person
2 { //成员变量
3 private String name;
4 private int age;
5 private char sex;
6 //构造方法
7 Person(){
8 }
9 Person(String name,int age,char sex){
10 this.name = name;
11 this.age = age;
12 this.sex = sex;
13 }
14 //一些get和set方法
15 void setName(String name){
16 this.name = name;
17 }
18 String getName(){
19 return this.name;
20 }
21 void setAge(int age){
22 this.age = age;
23 }
24 int getAge(){
25 return this.age;
26 }
27 void setSex(char sex){
28 this.sex = sex;
29 }
30 char getSex(){
31 return this.sex;
32 }
33 //普通成员方法
34 void eat(){
35 System.out.println("我吃饭");
36 }
37 void sleep(){
38 System.out.println("我睡觉");
39 }
40 }
41 class Student extends Person
42 {
43 //自有的成员变量
44 private String stuNo;
45 //构造方法
46 Student(){
47 }
48 Student(String name,int age,char sex,String stuNo){
49
50 super(name,age,sex);//调用父类带参的构造方法
51 this.stuNo = stuNo;
52 }
53 //自有的get和set方法
54 void setStuNo(String stuNo){
55 this.stuNo = stuNo;
56 }
57 String getStuNo(){
58 return this.stuNo;
59 }
60
61 //自有的普通成员方法；
62 void study(){
63 System.out.println("我学习Java");
64 }
65 }
66 class Teacher extends Person
67 {
68 //成员变量
69 private String teaNo;
70
71 //构造方法
72 Teacher(){
73 }
74 Teacher(String name,int age,char sex,String teaNo){
75 super(name,age,sex);
76 this.teaNo = teaNo; //给自有的成员赋值
77 }
78 //一些get和set方法
79 void setTeaNo(String teaNo){
80 this.teaNo = teaNo;
81 }
82 String getTeaNo(){
83 return this.teaNo;
84 }
85 //普通成员方法
86 void teach(){
87 System.out.println("我们教Java");
88 }
89 }
90 class Demo
91 {
92 public static void main(String[] args)
93 {
94 Teacher t1 = new Teacher();
95 t1.setName("小明"); //继承的
96 t1.setAge(20); //继承的
97 t1.setSex(‘男‘); //继承的
98 t1.setTeaNo("it_tea_001"); //自己的
99
100 t1.eat(); //继承的
101 t1.sleep(); //继承的
102 t1.teach(); //自己的
103
104
105 }
106 }
四、多态
多态： 1.使用"父类"的变量，存储"子类对象的引用"，这种形式叫：多态 Person p = new Student();
多态前提和体现 1.有继承关系:(必须的) 2.有方法重写; 3.有父类引用指向子类对象；(必须的)
1 class Person
2 {
3 String name;
4 int age;
5 }
6 class Student extends Person
7 {
8 }
9 class Teacher extends Person
10 {
11 }
12 class Employee
13 {
14 }
15 class Demo
16 {
17 public static void main(String[] args)
18 {
19 //继承后，我们一般情况下，都直接使用子类
20 Student stu = new Student();
21 stu.name = "张三";
22 stu.age = 20;
23 System.out.println(stu.name + "," + stu.age);
24
25 //使用多态：父类的变量存储了子类的引用
26 Person p = new Student();//多态；
27 p.name = "李四";
28 p.age = 22;
29 System.out.println(p.name + "," + p.age);
30
31 Person p2 = new Teacher();
32 p2.name = "王五";
33 p2.age = 20;
34 System.out.println(p2.name + "," + p2.age);
35
36 // Person p3 = new Employee();//错误的，Employee没有继承自Person
37 }
38 }
------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------