java基础-面向对象01

最新推荐文章于 2022-07-06 09:53:00 发布

置顶神探小神马

最新推荐文章于 2022-07-06 09:53:00 发布

阅读量200

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/aquanyt/article/details/116451796

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

p174-

面向对象编程上

三条主线

JAVA类以及类的成员、属性、方法、构造法；代码块、内部类
面向对象的三大特征：封装、继承、多态
其他关键字：this，super,static,abstract，interface，package，Import；

属性 = 成员变量 = field = 域，字段
方法 = 成员方法 = 函数 = method

persion类

p178

package persion;
// 类和对象的使用（面向对象思想的实现）
// 1.创建类，设计类的成员
// 2.创建类的对象
// 3.通过对象、属性或对象、方法调用对象的结构

// 测试类
public class persion {
    public static void main(String[] args) {
        // 创建persion1对象
        persion1 p1 = new persion1();
         // 调用
        p1.name = "tom";
        p1.isMale = true;
        System.out.println(p1.name);
        
        // 调用方法
        p1.eat();
        p1.sleep();
        p1.talk("Chinese");
    }
}

class persion1 {
    // 属性
    String name;
    int age = 1;
    boolean isMale;

    // 方法
    public void eat(){
        System.out.println("人可以吃饭");
    }

    public void sleep() {
        System.out.println("人可以睡觉");
    }

    public void talk(String language) {
        System.out.println("人可以睡觉，使用的是" + language);
    }

}

p180
如果创建了一个类的多个对象，则每个对象独立拥有一套类的属性（非static的）；这意味着，如果我们修改一个对象的属性a，则不影响另一个对象的属性a的值；

对象的内存解析

p181

在这里插入图片描述

堆（heap）

此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在java虚拟机规范中的描述是：所有的对象实例以及数组都要在对上分配。

栈（stack）

是指虚拟机的栈。虚拟机栈用于存储局部变量等。局部变量表存放在了编译器可知长度的各种基本数据类型（boolean,byte、char、int、short、float、long、double）、对象引用（reference类型，他不等同于对象本身，是对象在堆内存放的首地址）。方法执行完，自动释放。

方法区（method area）

用于存储已经被虚拟机加载的类型信息、常量
、静态变量、即时编译器编译后的代码等数据。

Persion p1 = new Persion();
p1.name = "tom";
p1.isMale = true;
Persion p2 = new Persion();
System.out.println(p2.name);
Persion p3 = p1;
p3.age = 10;
System.out.println(p3.name);

代码中的p1,p2,p3 是存放在栈中的指针，指向的是堆中的对象的首地址；
在这里插入图片描述

属性的使用

P182，p183

属性（成员变量）vs 局部变量

相同点
不同点

1 在类中声明的位置不同
属性：直接定义在类的一对{}内
局部变量：生命在方法内、方法形参、代码块内、构造器形参、构造器内部的变量；
2 关于权限修饰符的不同
属性：可以在生命属性时，知名其权限，使用权限修饰符。
常用的权限修饰符：private,public,protected,缺省；
局部变量：不可以使用权限修饰符
3 默认初始化值
属性：类的属性，根据其类型，都有默认的初始化值
整型（byte，short、int、long）：0
浮点型（float，double）0.0
字符型（char）0 或者（’\u0000’）
布尔类型（boolean）false
引用数据类型（类，数组，接口）：null

局部变量：没有默认初始化值，再调用局部变量必须显式赋值；特别地，形参在调用时，我们赋值即可。

在内存中的位置不同
属性：加载到堆空间中（非static的属性）
局部变量：加载到栈空间中

方法的声明与使用

p184 、p185、p186

方法的声明：权限修饰符返回值类型函数名（形参列表）{} NOTE : static、final、abstrat 来修饰方法，以后再讲。

权限修饰符： private，public，缺省，proteced；

返回值类型关键字；：有返回值vs无返回值
如果方法有返回值，必须在方法声明时，指定返回值类型，同时函数体中需要用return；

如何方法没有返回值，则方法声明时，使用void，通常情况下，函数体中不需要返回值，也可以加上return;表示结束此方法的意思；

我们定义方法时需不需要返回值？经验

方法名：标识符的要求

形参列表：

方法体：方法功能的体现

return关键字的使用

return关键字后面不可以声明执行语句。

P188

package CircleTest;

public class CircleTest {
    
}

// Circle
class Circle {
    double radius;
    double area;
    // 求圆的面积
    public double findArea() {
        area =Math.PI * radius * radius;
        return area;
    }
}

---------------------------------------------P193

匿名对象

理解：我们创建的对象，没有显示的肤质给一个变量名，则为匿名对象。
特征：匿名对象在其生命周期只能调用一次

重载 overload

定义：

在同一个类，允许一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
和返回值类型、方法的权限修饰符、方法体、形参变量名无关。
通过对象调用方法时，如何确定某个指定的方法：
①方法名
②参数列表

Varargs(variable number of argument)

javaSE 5.0中提供了Varargs机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方法，来传递个数可变的实参。

public class StringUtil {
    public static void main(String[] args) {
        StringUtil teSt = new StringUtil();
        teSt.show(12);
        teSt.show("hello");
        teSt.show("hello", "jack"); 
    }
        public void show(int i) {
           System.out.println("show(int i)"); 
        }
        
        public void show(String s) {
            System.out.println("show(String s)"); 
        }
        // 可变参数个数机制
        public void show(String ...strs) {
            System.out.println("show(String ...strs)"); 
        }
        // 与上面的函数冲突。
        public void show(String[] strs) {
            System.out.println("show(String ...strs)"); 
        }
        
}

具体使用

① 可变个数形参的格式：数据类型 …变量名
② 当调用可变个数形参的方法时，传入的参数个数可以是0个，1个，2个。。。
③ 可变个数形参的方法与本类中的方法名相同，形参不同的方法之间构成重载。
④ 可变个数的形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，两者不能构成重载。
⑤ 可变个数形参在方法的形参中，必须声明在末尾，而且只有一个可变个数形参

方法参数的值传递机制

① 如果变量是基本数据类型，此时赋值的是变量所保存的数据值

public class ValueTransferTest {
    public static void main(String[] args) {
    int m = 10;
    int n = m;
    System.out.println("m = " + m +", n = " + n);
    n = 20;
    System.out.println("m = " + m +", n = " + n);
    
    System.out.println("------引用数据类型----------");
    Order o1 = new Order();
    o1.orderID = 1001;
    Order o2 = o1; // 赋值以后，o1 和 o2的地址值相同，都指向了同一个对象实体
    System.out.println("o1.orderID = " +o1.orderID + " , o2.orderID = " + o2.orderID);
    o2.orderID = 1002;
    System.out.println("o1.orderID = " +o1.orderID + " , o2.orderID = " + o2.orderID);
}
}

class Order{
    int orderID;
}

p212

②如果参数就是引用数据类型，此时实参付给形参的是实参存储数据的地址值。
代码如下：

package ValueTranser;

public class ValueTranserTest {
    public  static void main(String[] args) {
        Data data = new Data();
        data.m = 10;
        data.n = 20; 
        System.out.println("m = " + data.m +" , n = " + data.n);
        
        // 交换
        ValueTranserTest test = new ValueTranserTest();
        test.swap(data);
        System.out.println("m = " + data.m +" , n = " + data.n);
    }
    
    public void swap(Data data) {
    int temp = data.m;
    data.m = data.n;
    data.n = temp;
}
}
class Data{
    int m;
    int n;
    
}

内存模型分析

联系6

package ValueTranser;

public class PassObject {
    public static void main(String[] args) {
        PassObject testObject = new PassObject();
        Circle c = new Circle();
        testObject.printAreas(c, 5);
    }
    
        public void printAreas(Circle c, int time) {
            System.out.println("Radius \t\tArea");
            for (int i = 1; i < time; i++) {
                // 设置半径
                c.radius = i;
                System.out.println(c.radius + "\t\t" + c.findArea());
            }
        }
}

package ValueTranser;

public class Circle {
    double radius;
    public double findArea() {
        return Math.PI * radius *radius;
    }
}

p216

递归略

p221

封装

程序设计的追求高内聚，低耦合
① 高内聚：类的内部数据操作细节自己完成，不允许外部干涉
② 低耦合仅对外暴露少量的方法用于使用。

package Animal;
/*
   *   面向对象的特征之一：封装与隐藏
 *  问题的引入
 *  当我们创建一个类的对象以后，我们可以通过“对象”， ”属性“
 *  的方式，对对象的属性进行赋值，这里，赋值的操作要受到数据类型
 *  和存储范围的制约。
*  
 *  封装行的体现
 *  我们将类的属性私有化，同事，提供公共的方法的获取和设置改属性
 *  
 *  ② 不对外暴露酥油的方法
 *  单例模式
 *  
 */
public class AnimalTest {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.nameString = "大黄";
        a.age = 1;
        //a.legs = 4;
        a.setlegs(3);
        a.show();
        a.setlegs(-1);
        a.show();
    }
}
class Animal{
    String nameString;
    int age;
    private int legs;
    
    public void eat() {
        System.out.println("动物进食");
    }
    
    public int getLegs() {
        return legs;
    }
    public void setlegs(int i) {
        if (i > 0) {
            legs = i;
        }
        else {
            legs = 0;
        }
    }
    public void show() {
        System.out.println("name = " +nameString + " , age = " +
    age + " , legs = " + legs);
    }
}

权限

封装的体现：需要权限修饰符来配合
① java的四种权限（从小到大）
private：
缺省：
protected：
public：

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
缺省	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

② 四种权限可以修饰的类以及类的内部结构：属性、方法、构造器、内部类
③ 具体的，四种权限可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话只能是缺省和public；

P224

神探小神马

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java基础-面向对象01

面向对象面向对象编程上三条主线对象的内存解析p174-面向对象编程上三条主线JAVA类以及类的成员、属性、方法、构造法；代码块、内部类面向对象的三大特征：封装、继承、多态其他关键字：this，super,static,abstract，interface，package，Import；属性 = 成员变量 = field = 域，字段方法 = 成员方法 = 函数 = methodpersion类p178package persion;// 类和对象的使用（面向对象思想的实现）/
复制链接

扫一扫