小丑西瓜9

这个屌丝很懒，什么也没留下！

热门标签

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

作者：小丑西瓜9 | 2024-02-24 22:51:25

踩

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关键字可以申明一个类从另一个类继承而来的


class 父类{
    ...       //成员变量、成员方法
}
class 子类 extends 父类{
    ...       //类体
}

举例：


class Person{             //声明一个Person类为父类
	String name;      	   //定义父类的成员变量name、age   
	int age;
	void show(){           //定义父类成员方法，将成员变量输出
		System.out.println(name); 	  
		System.out.println(age); 
	}
}
class Student extends teacher {     //声明一个Student类为子类并继承父类
}
public class myfirst {
	public static void main(String[] args) {
	Student student=new Student();     //声明一个Student类的实例对象student
	student.name="Tom";                //子类调用父类的成员变量name并赋值
	student.age=19;                    //子类调用父类的成员变量age并赋值
	student.show();                    //子类调用父类的成员方法show
	}
}

10.3特点：

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

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

10.4重写父类中的方法：

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

重写父类中的方法：

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


class Person{
	public void eat() {                      //输出人吃饭
		System.out.println("人吃饭");
	}
	
}
class North extends Person {           
    public void eat() {                      //输出北方人吃面条
    	System.out.println("北方人吃面条");
    }
}
public class myfirst {
	public static void main(String[] args) {
	North north = new North();                  //创建子类的一个实例对象，使用默认构造方法
	north.eat();                               //调用子类中重写的方法
                                
	}
}

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子类从而实例抽象类


package day0524;
 
public class demo04 {
    public static void main(String[] args) {
        People p=new Stu();
        p.eat();
        //调用特有的方法
        Stu s=(Stu)p;
        s.study();
        //((Stu) p).study();
    }
}
class People{
    public void eat(){
        System.out.println("吃饭");
    }
}
class Stu extends People{
    @Override
    public void eat(){
        System.out.println("吃水煮肉片");
    }
    public void study(){
        System.out.println("好好学习");
    }
}
class Teachers extends People{
    @Override
    public void eat(){
        System.out.println("吃樱桃");
    }
    public void teach(){
        System.out.println("认真授课");
    }
}

例二：


public class demo1 {
    public static void main(String[] args) {
        A a=new A();
        a.show();
        B b=new B();
        b.show();
    }
}
class A{
    public void show(){
        show2();
    }
    public void show2(){
        System.out.println("A");
    }
}
class B extends A{
    public void show2(){
        System.out.println("B");
    }
}
class C extends B{
    public void show(){
        super.show();
    }
    public void show2(){
        System.out.println("C");
    }
}

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