JAVA学习笔记,Java编制程序理念笔记

by admin on 2019年8月15日

对象的赋值,对象赋值

  对指标开始展览操作时,大家真正操作的是对指标的援用。“将几个对象赋值给另贰个目的”,实际上是将“援用”从八个地点复制到另贰个地方。参加对指标c=d,那么c和d都指向原本只有d指向的格外目的。

 1 class Tank{
 2     int level;
 3 }
 4 
 5 public class AssignmentObjects {
 6     public static void main(String[] args){
 7         Tank t1=new Tank();
 8         Tank t2=new Tank();
 9         t1.level=9;
10         t2.level=47;
11         System.out.println("t1 is"+t1.level+" t2 is"+t2.level);
12         t1=t2;
13         System.out.println("t1 is"+t1.level+" t2 is"+t2.level);
14         t1.level=27;
15         System.out.println("t1 is"+t1.level+" t2 is"+t2.level);
16         
17     }
18 }

 

对对象举行操作时,我们的确操作的是对指标的引用。“将二个目的赋值给另贰个对象”,实际上是将“援用”从一…

  赋值使用操作符“=”。它的意趣是“取侧面的值(即右值),把它复制给左侧(即左值)”。右值能够是其他常数、变量也许表达式(只要它能生成二个值就行)。但左值必须是一个斐然的、已命名的变量。也便是说,必须有一个大意空间能够积攒等号右侧的值。

参考来源:《java编制程序思想(第四版)》 见第三章3.4节

1.援引类型有哪些?非援用类型有何样

基本类型值(Number、Boolean、string、null和undefined):指的是保留在栈内部存储器中的归纳数据段;
引用类型值(对象、数组、函数、正则):指的是这一个保存在堆内存中的目的,变量中保留的实在只是贰个指针,这一个指针试行内部存款和储蓄器中的另一个任务,由该职责保存对象

一、基本数据类型的赋值

  对骨干数据类型的赋值是很简短的。基本数据类型存款和储蓄了事实上的数值,而毫无针对三个对象的援用,所以在为其赋值的时候,是一向将八个地点的剧情复制到了另二个地点。

  public class TestA{
      public static void main(String[] args){
        int a,b;
        b=9;
        a=b;
        System.out.println("1.a="+a+"   "+"b="+b);  
        a=10;
        System.out.println("2.a="+a+"   "+"b="+b);  
      }
 }
 /*
*输出结果:
 *1.a=9  b=9
 *2.a=10  b=9
 */

  上述代码,对骨干数据类型使用a=b,那么b的剧情就复制给了a。若接着又修改了a,而b根本不会惨遭这种修改的影响。但在对目的“赋值”的时候,情状却天差地远。

主题数据类型存款和储蓄了事实上的数值,并不是针对贰个对象的援引,故其赋值,正是一贯将二个地点的开始和结果复制到了另一个位置。比方,对骨干数据类型使用a=b,那么b的剧情就复制给a,而b根本不会受这种修改的震慑。不过作为对象“赋值”的时候,真正操作的是对“对象”的援引。所以只要“将贰个指标赋值给别的二个对象”,实际是将“引用”从一个地点复制到另一个地点。这代表一旦对目的使用c=d,那么c和d都指向原来唯有d指向的老大指标。**


JAVA学习笔记,Java编制程序理念笔记。2.之类代码输出什么?为啥

var obj1 = {a:1, b:2};
var obj2 = {a:1, b:2};
console.log(obj1 ==
obj2);输出//false;因为是八个例外的指针,分别指向差异的堆内的对象
console.log(obj1 = obj2);//输出Object {a: 1, b:
2};将obj2赋值给obj1;
console.log(obj1 ==
obj2);//输出true;援引类型的赋值是目的引用,指向同三个地点

JAVA学习笔记,Java编制程序理念笔记。二、对象的“赋值”

  对多少个目的开始展览赋值操作时,大家真正操作的是指标的引用。所以将三个对象赋值给另二个目标,实际是将“引用”从叁个地点复制到另二个地点。那表示如若对目的使用c=d,那么c和d都指向原来唯有d指向的万分目的。

public class Person {
    int age;
}
public class TestB {
    public static void main(String[] args) {
        Person p1=new Person();
        Person p2=new Person();
        p1.age=10;
        p2.age=20;
        p1=p2;
        System.out.println("1.p1.age="+p1.age+" p2.age="+p2.age);
        p1.age=15;
        System.out.println("2.p1.age="+p1.age+" p2.age="+p2.age);
    }
}
/*
 * 输出结果:
* 1.p1.age=20 p2.age=20
* 2.p1.age=15 p2.age=15
*/

  上述代码,对Person对象使用p1=p2,再对p1赋值时也改动了p2.那是由于p1和p2包蕴的是一样的援用,它们对准同样的指标。原来p1包括的对目的的征引,是指向八个值为10的对象。在对p1赋值的时候,那么些引用被遮住,也正是遗失了;而特别不再被引用的靶子会由“垃圾回收器”自动清理。


3.之类代码输出什么? 为何

var a = 1
var b = 2
var c = { name: ‘饥人谷’, age: 2 }
var d = [a, b, c]

var aa = a
bf88必发唯一官网,var bb = b
var cc = c
var dd = d

a = 11
b = 22
c.name = ‘hello’
d[2][‘age’] = 3

console.log(aa) //1;
原因:基本类型的复制,会在变量对象上创立三个新值,然后把该值复制到为新值配置的岗位上,该值只是一个别本,能够涉足另外操作不受影响。
console.log(bb) //2 ;
缘由同上
console.log(cc) // { name: ‘hello’, age: 3 } ;
缘由:引用类型的复制,同样会在栈中开采新的空间,是多个别本,不过这么些别本是叁个指针,那几个指针指向同三个目的。因而改换任何三个变量就能潜移暗化另个三个变量。操作c.name=’hello’改动了对象c的
name为hello;变量d中d[2]的指针指向对象c,操作d[2][‘age’],改变了指标c的age为3
console.log(dd) //[1,2,{ name: ‘hello’, age: 3 }]
案由:d 中保留的是基本类型a =1,基本类型b=2,
援用类型c ,依照在此之前描述的主干类型赋值,援用类型赋值的性状,a
,b不改变,操作c.name = ‘hello’
d[2][‘age’] = 3,均影象了对象c;

class Tank {
    int level;
}

public class Assignment {
    public static void main(String[] args) {
        Tank t1 = new Tank();
        Tank t2 = new Tank();
        t1.level = 9;
        t2.level = 47;
        System.out.println("1: t1.level: " + t1.level + ", t2.level: " t2.level);

        t1 = t2;
        System.out.println("2: t1.level: " + t1.level + ", t2.level: " t2.level);

        t1.level = 27;
        System.out.println("3: t1.level: " + t1.level + ", t2.level: " t2.level);

    }
    /* 输出:
     * 1:t1.level:9, t2.level:47
     * 2:t1.level:47, t2.level:47
     * 3:t1.level:27, t2.level:27
     */
}

4.如下代码输出什么? 为何

var a = 1
var c = { name: ‘jirengu’, age: 2 }

function f1(n){
++n
}
function f2(obj){
++obj.age
}

f1(a); //未有再次来到值,同期全局变量a 没赋值
f2(c); // 未有重临值,不过改动了援用类型c的age为3
f1(c.age) //未有再次回到值,同期全局变量a 没赋值
console.log(a) //1;由于每一遍操作没给a 赋值,所以a不改变。
console.log(c) // { name: ‘jirengu’, age: 3 }
//操作f2(c)改变了age为3;

5.过滤如下数组,只保留正数,直接在原数组上操作

var arr = [3,1,0,-1,-3,2,-5];

 function filter(arr){
    for(var i=0;i<arr.length;i++){
      if(arr[i]<=0){
          arr.splice(i,1)
          i--;
      } 
    }
}

filter(arr)
console.log(arr) // [3,1,2]

6.过滤如下数组,只保留正数,原数组不改变,生成新数组

var arr = [3,1,0,-1,-3,2,-5]
方法一;

function filter(arr){
    var arr2 =  arr.filter(function(item,index,array){//ie8以上
        return (item > 0)
  })
    return arr2;
}

方法二;

function filter(arr){
    var arr2=[];
    for(var i=0;i<arr.length;i++){
        if(arr[i]>0){    
           arr2.push(arr[i])
      }
    }
    return arr2
}

var arr2 = filter(arr)
console.log(arr2) // [3,1,2]
console.log(arr) // [3,1,0,-1,-2,2,-5]

7.写二个深拷贝函数,用二种方法完结

深拷贝领悟:深复制不是大概的复制引用,而是在堆中重新分配内部存款和储蓄器,而且把源对象实例的富有属性都开始展览新建复制,复制后的对象与原来的目的是一丝一毫切断的。
参照网站http://www.cnblogs.com/tracylin/p/5346314.html
方法一

 var array = {
    age:25,
    friends:{
        name:"andy",
        age:16
        }
    }
function deepCopy(oldObj){
  var newObj = {};
  for(key in oldObj){
    if(typeof oldObj[key]==="object" && oldObj[key]!= null){
        newObj[key]=deepCopy(oldObj[key])
    }else{
        newObj[key]=oldObj[key]
    }
}
   return newObj;
}
var obj2 = deepCopy(array);

方法二

var source = {
          name:"source",
          child:{
          name:"child"
          }
     }
var target = JSON.parse(JSON.stringify(source));

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图