java_java_内存溢出

介绍

一、设计对象并使用

1、设计类、创建对象并使用

2.定义类的补充事项

对象在内存中运行机制

3.多个对象内存

二、构造器

1、构造器的格式

2.定义调用构造器

3.注意事项

三、this关键字

四、封装

1.封装的概念：

2.正确的设计对象：

3.封装的优点：

4.如何进行更好的封装

五、 JavaBean

1.JavaBean的标准书写要求

2.一般会支持自动生成对应的set+变量名()、get+变量名()方法

3. 自动生成有参数构造器

4.自动生成无参数构造器

5.使用JavaBean创建对象封装一个对象信息

*成员变量和局部变量的区别

六、面向对象综合案例

介绍

面向对象编程我们可以简单的来理解

*面向：找

*对象：有状态和行为例如一条狗它的状态有颜色、名字、品种行为有摇尾巴、叫、吃等

*类：是一个模板它描述一类对象的行为和状态

*面向对象编程：找东西来编程的套路

面向对象的优点：

*编程简单符合人们的思维习惯更好理解

学习面向对象就是自己设计对象并进行使用

一、设计对象并使用 1、设计类、创建对象并使用

1.1类的结构：

public class 类名{
    1.成员变量 （通常以名词定义）
    2.成员方法 （通常以动词定义）
    3.构造器
    4.代码块
    5.内部类

}

成员变量：是定义在类中方法体之外的变量这种变量在创建对象的时候实例化成员变量可以被类中方法、构造方法和特定类的语句块访问

//例如：
public class Animal{
    //属性（成员变量）
    String name;
    int runs
    //行为（方法）
    public void eat(){
       //定义吃的方法内容
        System.out.println(name+"喜欢吃苹果");
    }
    
     public void run(){
       //定义跑的内容
        System.out.println(name+"每小时跑的公里数是"+runs);
    }
}

1.2 创建类对象

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

//例如： Add a = new Add();

1.3使用对象

//访问属性：
对象名.成员变量；

//访问行为：
对象.方法名(方法实参列表)；

案例：

第一步：

public class Animal{
    //属性（成员变量）
    String name;
    int runs
    //行为（方法）
    public void eat(){
       //定义吃的方法内容
        System.out.println(name+"喜欢吃苹果");
    }
    
     public void run(){
       //定义跑的内容
        System.out.println(name+"每小时跑的公里数是"+runs);
    }

第二步：

public class Test{
    public static void main(String[] args){
        //创建类
        Animal a = new  Animal();
        //使用类
        a.name = "小猴子";
         a.runs = 20;
        //打印输出
        System.out.println(c.name);
        System.out.println(c.runs);
        //调用变量
        c.name();
        c.runs();
    }
}

执行结果：

小猴子
20
小猴子喜欢吃苹果
小猴子每小时跑的公里数是20

2.定义类的补充事项

2.1、类名的首字母建议大写满足驼峰模式不能使用关键字（合法标识符且有意义）

2.2、一个java文件中可以定义多个class类，但只能一个是public修饰而public修饰的类名必须为代码文件名。

2.3、成员变量的完整格式是

修饰符 数据类型 变量名称 = 初始化值;
//一般无需指定初始化 存在默认值

默认值规则：
byte short int long  0

double float         0.0

boolean              false

String               null

对象在内存中运行机制 3.多个对象内存

1.1对象是放在堆内存中的

1.2一个类如：Animal a = new Animal();存储的是对象在堆内存中的地址

1.3成员变量的数据放在对象中存于堆内存中

二、构造器

概念：定义在类中可以用于初始化一个类对象并返回对象地址

1、构造器的格式

修饰符 类名(形参列表){
    …………
}

例如：

public calss Animal{
    //无参数构造器
    public Animal{
        …………
    }
    //有参数构造器
    public Animal(String name,int runs){
        …………
    }
}

*无参数构造器（默认存在）初始化对象时成员变量数据均采用默认值

*有参数构造器在初始化对象的时候，同时可以接收参数为对象进行赋值

2.定义调用构造器

类 变量名 = new 构造器；
//如：
Animal a = new Animal();

3.注意事项

3.1任何类定义出来默认值就自带了无参数构造器

public calss Animal{
    //无参数构造器默认存在
}

3.2如果一旦定义了有参数构造器那么无参数构造器就没有了如何还想使用无参数构造器就要从新写一个无参数构造器

三、this关键字

this 关键字可以出现在构造器、方法中

带表当前对象地址

public class Animal {
        //定义一个构造器
        public Animal(){
            System.out.println("this在构造器中返回的是"+this);
        }
        定义一个方法
        public void run(){
            System.out.println("this在方法中返回的是"+this);
        }

}

执行下面代码

public class aww {
    public static void main(String[] args) {
       //定义类
        Animal a = new Animal();
        //使用输出
        a.run();
        System.out.println(a);
    }

}

执行结果：

this在构造器中返回的是Animal@7530d0a
this在方法中返回的是Animal@7530d0a
Animal@7530d0a

作用：可以用于指定访问房前对象的成员变量、成员方法

this出现在成员方法中的用法：

public class Animal {
    String name;
    double ps;

    public void ango(String name){
        System.out.println(this.name+"正在和"+name+"一起吃饭");
    }
}

public class aww {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.name ="小明";
        a.ango("小李");
    }
}

执行结果：

小明正在和小李一起吃饭

四、封装

面向对象三大特征：封装、继承、多态

封装是面向对象三大特征之一

1.封装的概念：

告诉我们如何正确的设计对象的属性和方法

2.正确的设计对象：

对象代表什么就得封装对应的数据提供数据对应行为

//封装可以被认为是一个保护屏障防止该类的代码和数据被外部类定义的代码随机访问

3.封装的优点：

//良好的封装能够减少耦合

//类内部的结构可以自由修改

//可以对成员变量进行更精确的控制

//隐藏信息，实现细节

#有需要直接去找对象减少了记忆和学习更能提高编程的效率

4.如何进行更好的封装

4.1一般建议对成员变量使用private（私有、隐藏关键字）进行修饰

4.2为每个成员变量提供配套的public修饰的getter、setter方法暴露其取值和赋值

例如：
public class zy1 {
    //成员变量使用private修饰符 只能在本类中访问
    private int age ;
    //提供配套的public修饰的getter、setter方法暴露其取值和赋值
    public void  setAge(int age){
       if (age>=0 && age<=200){
           this.age = age;
       }else {
           System.out.println("输入有误");
       }
    }
    public int getAge(){
        return age;
    }
}

public class ALL{
    public static void main(String[] args) {
        zy1 z = new zy1();
        z.setAge(22);
        System.out.println(z.getAge());
    }
}


输出结果：

22

五、 JavaBean

可以称为实体类，其对象可以用于在程序中封装数据

1.JavaBean的标准书写要求

*成员变量使用private修饰

*必须提供一个无参构造器（有参构造器可写可不写）

*提供变量对应的set+变量名()、get+变量名()方

2.一般会支持自动生成对应的set+变量名()、get+变量名()方法

在IDEA中鼠标右击点击Generate…

然后再点击Getter and Setter

然后在对话框选择变量名点击OK生成

3. 自动生成有参数构造器

在IDEA中鼠标右击点击Generate…

然后再点击Constructor

然后在对话框选择点击OK生成

有参数构造器生成之后必须提供一个无参数构造器

4.自动生成无参数构造器

前面步骤与生成有参数构造器一样最后在Constructor对话框中选择之后点击 selec None

5.使用JavaBean创建对象封装一个对象信息

public class zy1 {
    //成员变量建议使用private私有
    private String name;
    private double height;
    private double salary;

    //提供无参数构造器 /有参数构造器可选


    public zy1() {
    }

    public zy1(String name, double height, double salary) {
        this.name = name;
        this.height = height;
        this.salary = salary;
    }


    //提供变量对应的set+变量名()、get+变量名()方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

public class ALL{
    public static void main(String[] args) {
        //用无参数构造器创建对象封装一个信息
        zy1 z1 = new zy1();
        z1.setName("旋风小霹雳");
        z1.setHeight(175.5);
        z1.setSalary(1000.0);
        System.out.println(z1.getName());
        System.out.println(z1.getHeight());
        System.out.println(z1.getSalary());

        //用有参数构造器创建对象封装一个用户信息
        zy1 z2 = new zy1("雷霆小巴嘎",17505,3000.0);
        System.out.println(z2.getName());
        System.out.println(z2.getHeight());
        System.out.println(z2.getSalary());
    }
}

执行结果：

旋风小霹雳
175.5
1000.0
雷霆小巴嘎
17505.0
3000.0

*成员变量和局部变量的区别

区别	成员变量	局部变量
类中位置不同	类中、方法外	常见方法中
初始化值不同	有默认值无需初始化	没有默认值，使用前要完成赋值
内存位置不同	堆内存	栈内存
生命周期不同	随着对象创建而存在，对象消失而消失	随着方法调用而存在，方法运行结束而消失
作用域	只需在外面类中创建该对象就可以使用	在所归属的大括号中

六、面向对象综合案例

需求：使用面向对象编程模仿电影信息的展示

思路：1、一部电影就是一个java对象，需要先设计电影类，再创建电影对象

2、电影可以采用数组存储起来

3、依次遍历数组中每一个电影对象，取出信息进行展示

public class Movie {
    //成员变量
    private String name;
    private  double score;
    private String actor;

    //提供参数构造器

    public Movie() {
    }

    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }
    // getter+setter

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}

public class zy1 {
    public static void main(String[] args) {
        //设计电影类
        //定义一个电影类数组来存储3部电影对象
        Movie[] movies = new  Movie[3];
        movies[0] = new Movie("《复仇者联盟4：终局之战》",8.8,"安东尼");
        movies[1] = new Movie("《天堂的张望》",9.4,"杜斌");
        movies[2] = new Movie("《画皮》",7.7,"刘春");
        
        //遍历数组中每一个对象，获取信息后展示出来
        for (int i = 0; i < movies.length; i++) {
            Movie m = movies[i];
            //输出
            System.out.println("电影名："+m.getName());
            System.out.println("豆瓣评分："+m.getScore());
            System.out.println("电影导演："+m.getActor());
            System.out.println("______________________________");
        }
    }
}

执行效果：

电影名：《复仇者联盟4：终局之战》
豆瓣评分：8.8
电影导演：安东尼
______________________________
电影名：《天堂的张望》
豆瓣评分：9.4
电影导演：杜斌
______________________________
电影名：《画皮》
豆瓣评分：7.7
电影导演：刘春
______________________________

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/720076.html

java

发表评论

评论列表（0条）