首页 > 其他 > 详细

面向对象

时间:2019-04-23 22:51:38      阅读:150      评论:0      收藏:0      [点我收藏+]

1.对象(object):万事万物皆对象

  指具体的一个事物,具体的实体,占空间

  对象从属性和方法两个方面进行描述

    1)属性:指对象的特征(静态的)

    2)方法:指对象的动作或功能(动态的)

2.类(class)

  是具体相同或相似性质的对象的抽象

  描述的是一类事物,类页游属性和方法

  类是抽象的概念,不占空间

3.实际编程流程

  先写类

    创建类:写属性和方法

  再创建对象:(main方法)

    创建对象的格式:类名  对象名 = new  类名( );

    访问属性:对象名.属性

    调用方法:对象名.方法名( );

 1 public class Dog {
 2     /*
 3      * 狗:
 4      * 属性:品种、颜色、年龄、名字
 5      * 方法:(跑、叫),输出基本信息
 6      */
 7     //属性
 8     String type;
 9     String color;
10     int age;
11     String name;
12     //方法
13     public void info () {
14         System.out.println("这是一只" + color +"" + type);
15         System.out.println("" + name +"今年" + age + "岁了");
16     }
17 }
 1 public class TestDog {
 2     public static void main (String[] args) {
 3         //创建对象
 4         Dog d1 = new Dog();
 5         //赋值
 6         d1.age = 5;
 7         d1.color = "灰色";
 8         d1.name = "小白";
 9         d1.type = "长毛犬";
10         //调用
11         d1.info();
12     }
13 }

terminal终端运行结果:

技术分享图片

4.变量的作用域

  变量可以使用作用域(空间,由声明的位置决定)和生存期来衡量
  作用域:
  • 成员变量:直接声明在类中(类的属性),在该类中都可以使用
  • 局部变量:声明在某个方法或语句块内,只有在该方法或语句块内可以使用 
  注意:局部变量和成员变量重名,则采用就近原则

5.方法的调用

  如果a( )要调用b( )方法

  1)如果在同一个类中,直接调用

public void a ( ) {
    ......
    b();
    ......
}

  2)如果不在同一个类,必须先创建b( )所在的类的对象,然后对象名.b( )

public void a ( ) {
    ......
    Bird b1 = new bird();
    b1.b();
    ......
}

  面向对象的优点

  • 便于模拟现实世界
  • 隐藏细节
  • 有利于代码的重用

6.基本类型和引用类型的区别

基本类型 引用类型
存储单个数据 复合类型的,存储多个数据,并且还有方法
创建:int a;   必须用new分配内存: Dog d1 = new dog( )
使用:a = 5; 对象名.属性  对象名.方法( )
内存:存储在栈区 引用在栈区,实际数据在堆区
必须先赋值才能使用 系统会自动初始化(本类型的0值)

 

 

 

 

 

7.面向对象的主要特征:封装、继承、多态

一、属性的封装(隐藏,整体)

  方法:语句块的封装

  类:属性和方法的封装

1.访问修饰符

  private:私有的,只有本类可以访问

  默认的(default):只有本包内的类可以访问

  public:公有的,该项目的类都可以访问

  protected:保护的,只有本包的类和它的子类可以访问

2.this:表示本对象的

  作用:

  区分成员变量和局部变量。用this.调用的都是成员变量

  在构造方法中,调用本类其他的构造方法,格式:this(实参);  注意:该句必须位于第一句

3.属性封装的步骤:

  1. 将属性私有化
  2. 给属性提供公有的get和set方法
  3. 如果对值得范围有限制,在set方法中限制

  优点:可以灵活的控制属性的读,写,隐藏数据,更安全

 1 public class Teacher {
 2     /*
 3      * 属性:姓名、年龄、教授课程
 4      * 方法:自我介绍、讲课
 5      */
 6     //属性
 7     private String name;
 8     private int age;
 9     private String course;
10     //构造方法
11     public Teacher (String name,int age,String course){
12         this.setName(name);
13         this.setAge(age);
14         this.name = name;
15         System.out.println("Teacher(name,age,lesson)被调用!");
16     }
17     public void introduce(){
18         System.out.println(name+"老师今年"+age+"岁,教授"+course);
19     }
20     public void teach(){
21         System.out.println(name+"老师正在讲"+course+"课程。。。");
22     }
23 
24     public void teach(int n){
25         System.out.println(name+"老师正在讲"+course+"课程的第"+n+"章内容。。。");
26     }
27     public void teach(String text){
28         System.out.println(name+"老师正在讲"+course+"课程的"+text+"部分的内容。。。");
29     }
30   //为属性提供公有的get和set方法
31     public String getName() {
32         return name;
33     }
34 
35     public void setName(String name) {
36         this.name = name;
37     }
38 
39     public int getAge() {
40         return age;
41     }
42 
43     public void setAge(int age) {
44         if(age<30){
45             System.out.println("提示:年龄不能低于30岁!");
46             this.age=30;
47         }else{
48             this.age=age;
49         }
50     }
51 
52     public String getCourse() {
53         return course;
54     }
55 
56     public void setCourse(String course) {
57         this.course = course;
58     }
59 }

接着创建一个测试类:

 1 public class test {
 2     public static void main(String[] args) {
 3         // TODO Auto-generated method stub
 4 //        Teacher t1=new Teacher();
 5 //        t1.setName("姚明");
 6 //        t1.setAge(40);
 7 //        t1.setCourse("篮球");
 8 //
 9 //        t1.introduce();
10 //        t1.teach();
11 
12 
13         Teacher t2=new Teacher("李白",50,"诗歌");
14 //        t2.introduce();
15 
16 //        Teacher t3=new Teacher("张三丰","武术");
17 //        t3.introduce();
18 
19 //        t3.teach();
20 //        t3.teach(4);
21 //        t3.teach("太极拳");
22 
23 
24 //        int age=t1.getAge();
25 //        age++;
26 //        t1.setAge(age);
27 //        System.out.println("现在的年龄:"+t1.getAge());
28     }
29 }

二、构造方法(constructor)

1.作用:负责对象成员的初始化工作(给属性赋值)

2.语法:与类同名,没有返回值类型的方法

3.什么时候调用:创建对象时,用new关键字调用

4.注意:

  1. 如果类中没有自定义的构造方法,系统会自动添加一个默认的无参的构造方法;如果类中有自定义的构造方法,系统就不在添加了
  2. 构造方法可以重载(不能被继承,不能被重写)

    方法重载:overloading,在同一个类中,方法名相同,参数列表不相同

5.实例代码块

直接放在类中的用{ }起来的代码,也是用来做初始化工作

三、继承

1.继承(inherit):从一个类出发生成另外一个类的过程

  父类:super class 超类,based class 基类

  子类:subclass,派生类或导出类或衍生类  derived class

2.继承的关键字:extends

3.继承需要注意的问题:

  子类是否可以继承父类所有的成员?

    私有的成员可以继承到,但是不能直接访问

    访问修饰符:都可以继承,不能直接访问

  构造方法

    创建子类对象时,默认调用父类无参的构造方法,如果要调用必须用super关键字显式调用,格式:super(实参);注意:必须位于第一句

    一个类只能有一个父类(java继承的单根性,单继承)

    所有类的根类:java.lang.object

    子类可以重写父类的方法

4.方法重写:overriding(方法覆盖)

  在子类中存在与父类中方法名参数列表返回值类型完全一致的方法,这时就称子类重写了父类的方法。要求:访问范围不能缩小

5.优点:可以有效的实现代码重用

四、多态

  具有表现多种形态的能力

  同样的一条语句,多次执行,结果可能不同

1.引用类型之间的转换

  自动转换:子类 => 父类

    又称为类型的自动提升,向上转型,上溯转型

    如果子类重写了父类的方法,调用该方法时,看实际类型(new后面的类型)

    注意:用父类的引用去调用父类中的方法,子类特有的方法无法调用

  强制转换

    子转父后,可以强制转换回子类对象

    类型自动提升后,可以强制转换回原类型或原类型的父类型

2.多态的实现方式

  1)方法重载:静态多态,编译时多态,在程序编译期间,根据参数列表去匹配

  2)方法重写:动态多态,运行时多态,在程序运行期间,根据对象的实际类型去选择执行哪个类中的方法

一般的多态都指方法重写所实现的多态,实现步骤:

  1. 要有继承关系和实现接口
  2. 要有方法重写
  3. 要有父类或接口引用去调用重写的方法(要有类型的自动提升)

面向对象

原文:https://www.cnblogs.com/mataoblogs/p/10759526.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!