当前位置:   article > 正文

java总结四(面向对象)_java有5人的类person,分别有:名字、性别、年龄、家庭住址、年龄(私有);构造方法带

java有5人的类person,分别有:名字、性别、年龄、家庭住址、年龄(私有);构造方法带

1、什么是面向对象

詹姆斯高斯林Java之父 ("万物皆对象")
​
本质是基于面向过程完成的;
​
面向过程的代表语言:C语言
  完成某一件事情,从分析,到实现,都是自己亲力亲为完成的!
  举例:
    需求:获取数组中的最大值
    分析:
        1)有一个数组
        2)定义参照物
        3)遍历其他数组
        3.1)获取到每一个元素,依次和参照物进行比较
        如果后面的元素比参照物大
        后面元素就是最大值
        4)输出结果;
        
 面向对象的代表语言:Java,c++,python...
 面向对象跟面向过程:
    
    生活中处处皆对象
    举例:
        洗衣服这件事情
        面向过程: 
            1)脱下脏衣服--->2)找一个盆子-----3)放入洗衣液-----4)泡一泡-----5)搓一搓-----6)透水
            ----7)拧一拧----->8)抖一抖-----9)晾一晾
        面向对象:
            1)脱下脏衣服---->2)全自动洗衣机(一键)----->3)晾一晾
            
            
       买笔记本:
        面向过程:
            了解自己的需要配置--->西安赛格电脑城----->看一看--->砍价-----> 被坑了..
        面向对象:
            了解自己的需要配置---->找一个懂行的朋友----->买回来
            
       做饭:
        面向过程;
             去菜市场---->看一看--->讨价还价--->摘菜----->洗菜---->切菜--->加油---->炒菜---放调料---->出锅
        面向对象:
             找一个对象---->等待出锅
             
     二、  面向对象的思想特点:
        1)更符合我们生活中思想行为习惯 
        2)让更复杂的事情简单化
        3)角色发生了变化:我们从执行者变成了指挥者!       
        
        什么是面向对象:    
            阐述下面向对象思想特点 + 结合我们中生活中的例子!

2.Java语言:面向对象语言---->它的设计原则

在程序中(符合生活中的场景),不断的创建对象,使用对象,指挥对象做事情(完成功能...)
举例:
    1)创建键盘录入对象:Scanner
    2)录入int类型/String类型数据
​

3.Java语言面向对象的三大特征

封装,继承,多态!

4.伪代码对比:面向过程/面向对象 ("将大象装进冰箱" 赵本山---)

将大象装进冰箱
伪代码:
面向过程
    1)测试类 main方法所在类
    2)分析:将大象装进冰箱
        定义三个方法:
            打开冰箱的方法
             将大象装进去的方法
            关闭冰箱的方法
                
                
     3)分别在main方法进行调用
                
           class Demo{
               public static void main(String[] args){
                   
                   //调用打开冰箱门的方法
                   open() ;
                   //将大象装进去
                   in() ;
                   //关闭冰箱门
                   close() ;
               }
               
               //定义一个打开冰箱门的方法
               public static void open(){
                   //使用输出语句,代替整个功能
                   System.out.println("打开冰箱门...") ;
               }
               
               //定义一个将大象装进去的方法
               public static void in(){
                   //...
                   System.out.println("将大象装进冰箱...") ;
               }
               
               //定义一个关闭冰箱门的方法
               public static void close(){
                   //...
                   System.out.println("关闭冰箱门...") ;
               }
           }     
 
​
//面向对象:"将大象装进冰箱"
//Java中最基本的单元类:
//分析: 有哪些名词  --- UML(名词提前法)----类
//分析:类中有哪些功能
//Demo类:测试类
//大象类 ---> "进去的功能"
//冰箱类 ---> "打开冰箱","关闭冰箱"
class Demo{//测试类
    public static void main(String[] args){
        
        //如果能够创建出冰箱类对象
        冰箱类对象.open() ;
        //如果创建出大象类对象
        大象类对象.in() ;
        冰箱类对象.close() ;
​
    }
}
​
​
//冰箱类
class 冰箱类{
    
        //定义一个打开冰箱门的方法
        public static void open(){
            //使用输出语句,代替整个功能
            System.out.println("打开冰箱门...") ;
        }
    
      //定义一个关闭冰箱门的方法
     public static void close(){
        //...
        System.out.println("关闭冰箱门...") ;
     }
}
//大象类
class 大象类{
      //定义一个大象进去的方法
        public static void in(){
               //...
          System.out.println("大象进去...") ;
        }
}
   

5.面向对象和类的关系

5.1什么是类

概念:能够描述一组事物的属性和行为的集合---->类

类------>能够描述现实世界真实存在的 "事物"

学生事物 属性:性别,年龄,姓名,学号,身高,班级,体重... 能够描述一个学生具体特点 行为: 主要的行为:学习, 吃,睡,玩.. 能够描述学生干什么

长方形事物 属性:长和宽 行为:计算它的周长/面积.... 汽车事物 属性:品牌,价格,车身颜色,100m速度,非承载式/承载式... 行为:旅游,拉货..... 现在使用Java代码的方式 描述现实世界存在的事物 Java中最基本的单元:类 -----> 事物 成员变量-------> 描述事物的属性 成员方法(非静态的)-------> 描述事物的行为

    成员变量: 在类中,方法外;
    成员方法: 之前怎么定义方法,现在还怎么写,不过,去掉static关键字
                public 返回这里类型 方法名(形式参数列表){
                        业务体
                        //有具体结果1)return 结果  ;
                        
                        //没有具体结果:输出 打印...
                }
    
                定义:
                        两个明确
                        1)明确返回值 :有-->给具体类型 ,没有:void 代替 输出结果
                        2)明确参数类型,以及参数个数
                                具体情况,具体分析

5.2对象和类的关系

类----描述真实事物的

    学生事物                
        属性:
            姓名
            年龄
            住址
            ..
        行为:
            学习JavaSE

学生类 class Student{ //成员变量 ---事物属性 String name ;//姓名 int age ;//年龄 String address;//住址 //...

            //成员方法----事物的行为
            public void study(String name){
                System.out.println("正在学习"+name) ;
            }
        }       
什么是对象?
        体现出 "具体的事物"       因为类---描述事物----概括的事物("总称")
                具体的学生:高圆圆,42,鄠邑区
                
    在测试类中使用:main方法所在类           
                
    代码体现:
        格式:
            类名 对象名  = new  类名() ;
            
            给具体事物属性赋值
            对象名.成员变量 = 根据类型赋值;
            调用具体事物的行为
            对象名.成员方法名() ;
 6.局部变量和成员变量区别

 
    1)在类中的书写位置区别
        局部变量:在方法定义中或者是方法声明上;
        成员变量:在类中,方法外;
    
    2)在内存中的位置不同
        局部变量:在栈内存中
        成员变量:在堆内存中
        
    3)生命周期不同:
        局部变量:随着方法调用而存在,随着方法调用结束而消失
        成员变量:随着对象的创建而存在,随着对象的调用完毕,等待垃圾回收器空闲时候回收,不会立即消失!
    4)初始化时机不同:
        局部变量:
            要么先定义,使用之前必须初始化;要么直接初始化
        成员变量:   
                可以不赋值,系统默认对成员变量初始化
                也可以通过对象名.成员变量 =赋值;

7.匿名对象

顾名知意:没有名字的对象

        创建对象的格式:

        类名 对象名 = new 类名();

        Student s = new Student();

        匿名对象的格式:

                new 类名();

                好处:

                        1)匿名对象可以作为参数传递!

                        2)节省内存空间

                        3)开发中,匿名对象一般 使用一次即可,使用完毕垃圾回收器立即回收

        访问类的成员变量:

                new 类名().成员变量名;

                访问类的成员方法:没有具体返回值类型

                new 类名().成员变量 名();

8、封装

                private:私有的,不能直接访问;

8.1 特点:

        被private修饰的成员变量或者成员方法,只能在本类中访问;

外界类是不能直接访问的,间接可以通过公共的成员方法访问;

权限修饰符:

        private :最小 public :最大

举例

        使用一个学生类,来描述学生事物

学生事物

        属性:姓名,年龄,性别,学号,爱好

        行为:学习,踢足球,看电影....

                定义一个学生类:Student

                成员变量私有化-----加入private

                name,age,gender,id,hobit

                成员方法:

                        set / get:给学生信息赋值/获取值

代码存在弊端:

          讲标识符:在实际开发中,起名字(变量/方法/类)见名知意 当前代码中的setXXX(形式参数):都是 n,a,g,i,h:不太合适 既然见名知意: name,赋值一个姓名 age:赋值年龄 gender:赋值性别 id:赋值学号 hobit:赋值爱好

9.this关键字

        局部变量名称和成员变量名称一致(局部变量隐藏了成员变量),Java提供了一个关键字:this
​
        this:代表当前类对象的地址值引用

10、继承

10.1什么是继承?

        继承就是子类继承父类的特征和行为,使的子类对象具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为

10.2继承的作用:

用过继承可以快速创建新的类,实现代码的重用,提高程序的可维护性,节约大量时间,提高开发的效率和质量

一般用extends关键字可以申明一个类从另一个类继承而来的

  1. class 父类{
  2. ... //成员变量、成员方法
  3. }
  4. class 子类 extends 父类{
  5. ... //类体
  6. }

举例:

  1. class Person{ //声明一个Person类为父类
  2. String name; //定义父类的成员变量name、age
  3. int age;
  4. void show(){ //定义父类成员方法,将成员变量输出
  5. System.out.println(name);
  6. System.out.println(age);
  7. }
  8. }
  9. class Student extends teacher { //声明一个Student类为子类并继承父类
  10. }
  11. public class myfirst {
  12. public static void main(String[] args) {
  13. Student student=new Student(); //声明一个Student类的实例对象student
  14. student.name="Tom"; //子类调用父类的成员变量name并赋值
  15. student.age=19; //子类调用父类的成员变量age并赋值
  16. student.show(); //子类调用父类的成员方法show
  17. }
  18. }

10.3特点:

java不支持多继承但是可以多层继承

构造方法不会被子类继承,但是可以从子类中调用父类的构造方法

10.4重写父类中的方法:

子类继承了父类中的所有成员及方法,有的情况下,子类中该方法所表示的行为与父类中的行为不完全相同,例如:父类中定义了吃饭这个方法 而子类中吃饭的方法不同:南方人吃米饭,北方人吃面条,这个时候就用到重写或隐藏父类中的该方法。

重写父类中的方法:

        当一个子类中一个实例方法具有其父类中的实例方法相同的名称(参数个数、名称,参数类型)和返回值时,称子类中的方法“重写”了父类的方法。

  1. class Person{
  2. public void eat() { //输出人吃饭
  3. System.out.println("人吃饭");
  4. }
  5. }
  6. class North extends Person {
  7. public void eat() { //输出北方人吃面条
  8. System.out.println("北方人吃面条");
  9. }
  10. }
  11. public class myfirst {
  12. public static void main(String[] args) {
  13. North north = new North(); //创建子类的一个实例对象,使用默认构造方法
  14. north.eat(); //调用子类中重写的方法
  15. }
  16. }

10.5子类访问父类私有成员

                子类继承其父类的所有public和protected成员,但不能继承其父类的private成员。那么如何在子类中访问到父类中的字段呢,我们可以在父类中提供用来访问其私有字段的public或protected方法,子类使用这些方法来访问相应的字段。

10.5super

           子类重写了父类中的某一个方法,隐藏父类中的字段,假如想在子类中访问到父类中被重写的方法和隐藏父类的字段,可以在子类中通过使用关键字super来调用父类中被重写的方法和访问父类中被隐藏的字段。

10.6使用super调用父类的无参数构造方法/有参数构造方法

        

子类不继承其父类的构造方法。

        当使用无参数的super()时,父类的无参数构造方法就会被调用;

        当使用带有参数的super()方法时,父类的有参数构造方法就会被调用。

11、多态

11.1.多态的概念

        通俗来说,就是多种形态,具体点的就是去完成某个行为,当不同的对象去完成时就会产生不同的形态。

举例:如学生:学生是人的一种,而一个具体的学生是学生是学生也是人,就出现了两种形态。

11.2.多态的定义和与使用格式

        定义格式:父类类型 变量名=new 子类类型();

11.3.多态中成员的特点:

1.编译看左边,运行看右边

2.多态不能直接访问子类,也就是不能直接由上向下转型,需要用到强制转换

3.将属性方法定义到一个类中,此类没有实例为抽象的也不能new对象,需要子类完成抽象类中的方法,都new子类从而实例抽象类

  1. package day0524;
  2. public class demo04 {
  3. public static void main(String[] args) {
  4. People p=new Stu();
  5. p.eat();
  6. //调用特有的方法
  7. Stu s=(Stu)p;
  8. s.study();
  9. //((Stu) p).study();
  10. }
  11. }
  12. class People{
  13. public void eat(){
  14. System.out.println("吃饭");
  15. }
  16. }
  17. class Stu extends People{
  18. @Override
  19. public void eat(){
  20. System.out.println("吃水煮肉片");
  21. }
  22. public void study(){
  23. System.out.println("好好学习");
  24. }
  25. }
  26. class Teachers extends People{
  27. @Override
  28. public void eat(){
  29. System.out.println("吃樱桃");
  30. }
  31. public void teach(){
  32. System.out.println("认真授课");
  33. }
  34. }

例二:

  1. public class demo1 {
  2. public static void main(String[] args) {
  3. A a=new A();
  4. a.show();
  5. B b=new B();
  6. b.show();
  7. }
  8. }
  9. class A{
  10. public void show(){
  11. show2();
  12. }
  13. public void show2(){
  14. System.out.println("A");
  15. }
  16. }
  17. class B extends A{
  18. public void show2(){
  19. System.out.println("B");
  20. }
  21. }
  22. class C extends B{
  23. public void show(){
  24. super.show();
  25. }
  26. public void show2(){
  27. System.out.println("C");
  28. }
  29. }

 

12.什么是构造方法:


    构造方法是一种特殊的方法,方法名和类名一致;
    
    特点:
        1)方法名和类名一致;
        2)构造方法没有返回值类型
        3)连void都没有

分类: 无参构造方法:没有参数 有参构造方法:有具体的参数类型

构造方法的作用:就是对类中的数据(成员属性)进行初始化

12.1构造方法的注意事项:

    1)当我们开发者既没有提供无参构造方法,也没有提供有参构造方法,

系统永远给我们提供 "无参构造方法" 类名 对象名 = new 类名() ; //创建对象的格式

    2)如果我们提供了有参构造方法,那么系统不会在提供无参构造方法
​
        构造方法的作用:给类的成员属性可以进行数据初始化

给成员变量(私有修饰)赋值几种方式: 1)公共的访问方法setXXX(xx):赋值 2)有参构造方法进行赋值 public 类名(参数类型1 变量名1,参数类名2 变量名2...){

            this.成员变量名1 = 变量1;
            this.成员变量名2 = 变量2 ;
            ...
        }
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小丑西瓜9/article/detail/136526
推荐阅读
相关标签
  

闽ICP备14008679号