java学习 零基础

基础知识掌握



JDK Java Development Kit java开发套件

文件名和类名要相同      文件名.java   === public class 文件名{}

java是一个一个类构成的

main是java的入口

mac环境变量设置

  • .zshrc
  • .bash_profile

查看机器上所有java版本:

[email protected] ~ $ /usr/libexec/java_home -V
Matching Java Virtual Machines (3):
    11.0.4, x86_64:    "Java SE 11.0.4"    /Library/Java/JavaVirtualMachines/jdk-11.0.4.jdk/Contents/Home
    9, x86_64:    "Java SE 9"    /Library/Java/JavaVirtualMachines/jdk-9.jdk/Contents/Home
    1.8.0_151, x86_64:    "Java SE 8"    /Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home

/Library/Java/JavaVirtualMachines/jdk-11.0.4.jdk/Contents/Home

src source的缩写

int 整数范围 -2^31~2^31-1        -2147483648~2147483647

标识符 Identifier

关键词 key word

二进制单位bit

Byte 硬盘存储单位  文件大小  1byte=8bit

整数:

  • byte 1个byte
  • short 2个byte
  • int 4个byte
  • long 8个byte

浮点数:

  • float 4个byte
  • double 8个byte

布尔类型,字符类型:

  • boolean 1个byte
  • char 2个byte

布尔运算符:

  • ! 非
  • & and
  • &&     当第一个条件为假之后,后面的条件就不执行了,它具有短路功能   & 两个条件都要执行   运算结果与&相同
  • | 或
  • ||    运算结果与|相同

运算优先级:

  • ()
  • * / %
  • + -
  • > >= < <=
  • ==
  • !=
  • & && | ||
  • =

进制:

  • 0开头 8进制
  • 0X开头  16进制

按位运算符:

  • &
  • |
  • ^   异或运算
  • ~   取反

位移运算符:

  • >>    符号位不动
  • >>>  符号位动
  • <<    符号位不动

掩码 mask   类似于 onehot

数值精度:

double>float>long>int>short>byte

字符集:字符的集合

  • GBK常用汉字字符集合
  • ASII码
  • Unicode 全世界上所有常用字符 UTF-8、UTF-16
  • java是使用UTF-16

char  character字符

数字映射到字符 编码Encoding

Math.random(); 生成0到1之间的数字。

数组:

int[] book = new int[10];   都是地址

多维数组:

double[][] scource = new double[2][3];

输入:

Scanner in = new Scanner(System.in);

a = i.next;



java 的精髓

// >> TODO 高亮注释 以程序本身内无关

实例 Instance

对象 Object

数组是一个特殊的类,每个数组对象占用的内存可以不一样。,这点和类的对象不同,类的对象一定相同。

NULL 引用类型的缺省值,代表为空。

NULL带来的问题NullPointerException NPE

数组的index也是一种地址引用   Eg:merchandise[7].name

成员变量一样,但是类名不一样,类就不一样。

包和访问修饰符

com.phone.ljc 类似于这样

  • 包:层级关系   package   有package语句,则必须是类的第一行有效代码
  • package的访问管理   import

Java只要不在同一个目录下就看不到,如果想看到就要路径加上类名,使用import语句。

public 访问修饰符、默认访问修饰符,只能被同一个包package里的类访问,不是一个包就不让访问。

包名package+类名=类的权限定名,同一个java中权限定名不重复,类名可以重复。

Method = Function

不可以用类调用方法,需要对象访问方法。

可以访问 局部变量 以及 成员变量

@see 和哪些类还有关系

@since 从jdk的什么版本开始有的

成熟的类,自己操作自己的成员变量。

成员变量是内部的状态。

1         Merchandise m1 = new Merchandise();
2         m1.name = "旺仔小馒头!";
3         m1.id = "32423432";
4
5         m1.init("旺仔小馒头!", "32423432");

封装:自己管控、逻辑公用、避免重复

把类的数据和操作都放在一起

方法的签名:方法名+依次参数类型  返回值不属于方法签名、方法签名是一个方法在一个类中的唯一标识。

也就是:方法重载overload

重载的参数匹配规则,

double:int、double、short、byte

参数类型不完全匹配,会自动适配。

类型重载规则(不推荐这样使用):

  • double float
  • double long

构造方法constructor):创建一个对象,自动实例化对象。 构造方法与类名一致,构造方法不能有返回值。

没有构造方法默认为一个无参的构造方法。构造方法只是能初始化成员变量。new 返回创建对象的引用。

构造方法重载:构造方法的不同逻辑,通过参数的类型个数区分开。必须是第一行,参数不能访问this自引用,不能访问成员变量。

浮点数除以0不会报错,整数除以0会报错。

构造方法用this指向引用变量。

<init> 构造方法、或者给成员变量赋值

静态变量:也叫做类变量。

Magic Number 贬义词、不要直接上数字0.95.

cost = cost * 0.95;   ==》 cost = cost * discount;

static 不赋值,java也会给他一个初始值。静态变量命名:下划线 + 所有单词大写

静态变量就这一个,不会像成员变量一样,不用跟随对象的创建而创建,静态变量跟着类存在。

引用静态变量:

  • import static om.gee.XXX
  • 或者直接 类名.静态变量  在代码中使用

类 == 静态变量

静态方法:没有this自引用方法、类方法

静态方法的参数来自:方法自身的参数  和  静态变量(别的类或者自己类)

静态方法可以自己创建对象,或者通过参数调用,获得对象的引用,进而调用方法和访问成员变量。

方法也可以同import使用

静态方法的重载:成员方法重载一致

static代码块:给静态变量赋值,可以使用人任意类的静态变量。有先后顺序,定义在使用之前。

<clinit> 静态变量组织到这个方法中

访问修饰符:

  • public 全局可见
  • 缺省:当前包可见
  • private:当前类可以见

成员变量构造方法定义成private  可以自己修改

public方法类似于一种约定(契约),既然外面的代码可以使用,就意味着不能乱改,比如签名不能改之类的

Math 使用 static 将方法暴露处理啊,供调用。

string不可变,它是private的

StringBuild 用来凭借和处理字符串的类

继承不能访问父类的private成员

覆盖才是继承的精髓:签名和返回值一样的方法。

子类和分类沟通的桥梁 super,不可以使用super 访问分类的属性和方法,不可以使用子类成员变量和方法,可以使用静态方法。

调用父类的构造方法:

init()方法

40 多态

可以调用哪些方法,取决于引用类型,具体调用哪个方法,取决于实例所属的类是什么。

Java选择单继承的重要原因之一,在多继承的情况下,如果使用不当,多态可能会非常复杂,以至于使用的代价超过来了带来的好处。

多态:

  • 静态多态:重载 overload
  • 动态多态:覆盖 override

instanceof 操作符,可以片段一个指向的独享是否是某一个类型或者其子类是返回true,否则返回false

if(m instanceof Phone){

}

protected 对包和子类可见

final 不可以被集成,和修改

集成里的静态方法:

静态方法可以被继承

object没有成员变量,只有方法

重新更新java学习视屏笔记

1.类

Merchandise.java
 1 // >> TODO 一个类以public class开头,public class代表这个类是公共类,类名必须和文件名相同。
 2 // >> TODO public class后面紧跟类名,然后是一对打括号的类体
 3 public class Merchandise {
 4     // >> TODO 类体中可以定义描述这个类的属性的变量。我们称之为成员变量(member variable)
 5     // >> TODO 每个成员变量的定义以;结束
 6     String name;
 7     String id;
 8     int count;
 9     double price;
10
11 }
12
13 // >> TODO 上面这整个类,其实就是创建了一个模版。描述了一种我们需要的数据类型。

2.类的 实例 Instance 与 对象 Object

类就是自己常见了一种新的数据类型,类也就是自定义类型。以一个java程序中不允许类同名

SuperMarket.java
 1 public class SuperMarket {
 2     public static void main(String[] args) {
 3
 4         // >> TODO 使用new操作符,可以创建一个类的实例/对象( instance/object )。
 5         // >> TODO 使用new创建一个类的实例后,类中定义的每种变量都会被赋以其类型的初始值。
 6         //    TODO 这个和数组也是一样的
 7         // >> TODO 使用一个同类型的对象变量,可以指向并操作这个实例。这两点和数组都很类似
 8         // 创建一个Merchandise的实例,用m1指向它。
 9         Merchandise m1 = new Merchandise();
10         // 缺省值:每个对象的成员变量都会赋予成员变量的缺省值。
11
12         // 使用点操作符,给m1指向的实例赋值。
13         m1.name = "茉莉花茶包 20 包";
14         m1.id = "000099518";
15         m1.count = 1000;
16         m1.price = 99.9;
17
18         Merchandise m2 = new Merchandise();
19         m2.name = "可口可乐 330ml";
20         m2.id = "000099519";
21         m2.count = 1000;
22         m2.price = 3.0;
23
24
25         // 卖出一个商品1
26         int m1ToSold = 1;
27         System.out.println("感谢购买" + m1ToSold + "个" + m1.name + "。商品单价为"
28                 + m1.price + "。消费总价为" + m1.price * m1ToSold + "。");
29         m1.count -= m1ToSold;
30         System.out.println(m1.id + "剩余的库存数量为" + m1.count);
31
32         // 卖出3个商品2
33         int m2ToSold = 3;
34         System.out.println("感谢购买" + m2ToSold + "个" + m2.name + "。商品单价为"
35                 + m2.price + "。消费总价为" + m2.price * m2ToSold + "。");
36         m2.count -= m2ToSold;
37         System.out.println(m2.id + "剩余的库存数量为" + m2.count);
38
39
40         // >> TODO 点操作符是用来访问/操作前面实体的属性的,类似于“的”
41     }
42 }

3.引用类型

引用:reference

引用 = 类型 + 实例

引用数据类型和基本数据类型本身都是一个地址基本数据类型地址对应的值,就是变量的引用数据类型的值还是一个地址,通过“二级跳”找到实例。

ReferenceAndPrimaryDataType.java
 1 public class ReferenceAndPrimaryDataType {
 2     public static void main(String[] args) {
 3
 4         // >> TODO m1是一个Merchandise类型的引用,只能指向Merchandise类型的实例
 5         // >> TODO 引用数据类型变量包含两部分信息:类型和实例。也就是说,
 6         //    TODO 每一个引用数据类型的变量(简称引用),都是指向某个类( class /自定义类型)
 7         //    TODO 的一个实例/对象(instance / object)。不同类型的引用在Java的世界里都是引用。
 8         // >> TODO 引用的类型信息在创建时就已经确定,可以通过给引用赋值,让其指向不同的实例.
 9         //         比如 m1 就是Merchandise类型,只能指向Merchandise的实例。
10         Merchandise m1;
11         m1 = new Merchandise();
12         Merchandise m2 = new Merchandise();
13         Merchandise m3 = new Merchandise();
14         Merchandise m4 = new Merchandise();
15         Merchandise m5 = new Merchandise();
16
17         // >> TODO 给一个引用赋值,则两者的类型必须一样。m5可以给m1赋值,因为他们类型是一样的
18         m1 = m5;
19
20         System.out.println("m1=" + m1);
21         System.out.println("m2=" + m2);
22         System.out.println("m3=" + m3);
23         System.out.println("m4=" + m4);
24         System.out.println("m5=" + m5);
25         System.out.println();
26
27         Merchandise m6 = m1;
28         System.out.println("m6=" + m6);
29         m6 = m5;
30         System.out.println("m6=" + m6);
31         System.out.println();
32
33
34         System.out.println("m1=" + m1);
35         System.out.println("m2=" + m2);
36         System.out.println("m3=" + m3);
37         System.out.println("m4=" + m4);
38         System.out.println("m5=" + m5);
39
40
41         int a = 999;  // 基本数据类型
42
43     }
44 }

结果:

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]

[email protected]
[email protected]

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]

引用数据类型,引用的是什么?

heap堆  实例存放的地方 、类似于公告板的地方    比如:string 也是引用类型

m1本身就是一个地址、所以才需要使用二级跳

引用类型的大小:

  • 64位jdk  64bit
  • 32位jdk  32bit

堆内存、栈内存

类和对象的关系:

  • 类是对象的模板,对象是类的一个实例
  • 一个java程序中类名相同的类只能有一个,也就是类型不会重名
  • 一个类可以有很多对象
  • 一个对象只能根据一个类来创建

引用和类以及对象的关系:

  • 引用必须是,只能是一个类的引用
  • 引用只能指向其所属的类型的类的对象
  • 相同类型的引用之间可以赋值
  • 只能通过指向一个对象的引用,来操作一个对象,比如访问某个成员变量

数组

数组是一种特殊的类:

  • 数组的类名就是类型带上中括号
  • 同一类型的数组,每个数组对象的大小可以不一样,也就是每个数组对象占用的内存可以不一样,这点和类的对象不同。
  • 可以用引用指向类型相同大小不同的数组,应为它们属于同一个类型
 1 public class ArrayIsClass {
 2     public static void main(String[] args) {
 3         // >> TODO “数组变量”其背后真身就是引用。数组类型就是一种特殊的类。
 4         // >> TODO 数组的大小不决定数组的类型,数组的类型是只是由元素类型决定的。
 5         int[] intArr;
 6         intArr = new int[1];
 7         intArr = new int[2];
 8
 9         // 这个数组的元素就是二维的double数组,既double[][]
10         double[][][] double3DArray = new double[2][3][4];
11
12         int[] a1 = new int[9];
13         int[] a2 = new int[0];
14         a2 = a1;
15         System.out.println("a2.length=" + a2.length);
16         double[] a3 = new double[5];
17         // a3是double[]类型的引用,不可以用int[]类型的引用赋值。
18         double3DArray[1][2] = a3;
19     }
20 }

引用的数组

  • 可以把类名当成自定义类型,定义引用的数组,甚至多维数组
 1 public class RefArray {
 2
 3     public static void main(String[] args) {
 4         Merchandise[] merchandises = new Merchandise[9];
 5         merchandises[0] = new Merchandise();
 6         merchandises[1] = new Merchandise();
 7         merchandises[0].name = "笔记本";
 8         System.out.println(merchandises[0].name);
 9
10         System.out.println(merchandises[2]);
11     }
12 }

笔记本
null

缺省值

  • null是引用类型的缺省值
  • null代表空,不存在。可以读作空
  • 引用类型的数组创建出来,初始值都为空。
  • 带来NuLLPointerException(NPE)需要先判空在运行引用
  • 直接输出null没有关系,但是引用的值输出则会报错。
 1 public class CheckBeforeUse {
 2     public static void main(String[] args) {
 3         // 数组在创建出来之后,会按照类型给数组中的每个元素赋缺省值。
 4         // 引用类型的缺省值是null
 5         Merchandise[] merchandises = new Merchandise[9];
 6         // 给索引为偶数的引用赋值
 7         for (int i = 0; i < merchandises.length; i++) {
 8             if (i % 2 == 0) {
 9                 merchandises[i] = new Merchandise();
10             }
11         }
12
13         // merchandises[7].name = "不存在的商品,不存在的名字";
14
15         for (int i = 0; i < merchandises.length; i++) {
16             if (merchandises[i] != null) {
17                 merchandises[i].name = "商品" + i;
18             }
19         }
20
21         for (int i = 0; i < merchandises.length; i++) {
22             if (merchandises[i] != null) {
23                 System.out.println(merchandises[i].name);
24             }
25         }
26     }
27 }

5.自定义类

command / cutrl + 鼠标  点击会跳转类

引用类型可以随意组合

6.package管理

  • 为了避免类在一起混乱,可以把类放在文件夹中。
  • 不同包可以有相同名字的类
  • 一个类只能有一个package语句,如果有package语句,则必须是类的第一行有效代码
  • 其中.就是package

7.public

访问修饰符:

  • 缺省访问修饰符,只能被同一个包package下面的文件访问。private
  • public可以被任意包访问

类的全限定名 = 包名 + 类名  同一个java程序中权限定名不能重复

java就是使用类来描述世界,用类的实例让世界运转起来。

设置断点(breakpoint),debug调试运行程序。

8.方法

方法 Method Function 让类描述自己

 1 package com.geekbang.supermarket;
 2
 3 public class MerchandiseV2 {
 4
 5     public String name;
 6     public String id;
 7     public int count;
 8     public double soldPrice;
 9     public double purchasePrice;
10     String madeIn;
11
12     // >> TODO 访问修饰符
13     // >> TODO 返回值类型:无需返回值则用void表示,void是Java中的关键字
14     // >> TODO 方法名:任意合法的标识符都可以
15     // >> TODO 参数列表:后续讲解
16     // >> TODO 方法体:方法的代码
17     // >> TODO 方法体内部定义的变量叫做局部变量
18     public void describe() {
19         double netIncome = soldPrice - purchasePrice;
20         System.out.println("商品名字叫做" + name + ",id是" + id + "。 商品售价是" + soldPrice
21                 + "。商品进价是" + purchasePrice + "。商品库存量是" + count +
22                 "。销售一个的毛利润是" + netIncome + "。制造地为" + madeIn);
23     }
24 }

方法可以使用的数据:对象的成员变量(member variable)

 1 package com.geekbang.supermarket;
 2
 3 public class MerchandiseV2DescAppMain {
 4     public static void main(String[] args) {
 5         MerchandiseV2 merchandise = new MerchandiseV2();
 6
 7         merchandise.name = "书桌";
 8         merchandise.soldPrice = 999.9;
 9         merchandise.purchasePrice = 500;
10         merchandise.count = 40;
11         merchandise.id = "DESK9527";
12         merchandise.madeIn = "China";
13
14         merchandise.describe();
15     }
16 }

方法返回值

 1 package com.geekbang.supermarket;
 2
 3 public class MerchandiseV2 {
 4
 5     public String name;
 6     public String id;
 7     public int count;
 8     public double soldPrice;
 9     public double purchasePrice;
10
11     public void describe() {
12         System.out.println("商品名字叫做" + name + ",id是" + id + "。 商品售价是" + soldPrice
13             + "。商品进价是" + purchasePrice + "。商品库存量是" + count +
14             "。销售一个的毛利润是" + (soldPrice - purchasePrice));
15     }
16
17     // >> TODO 在方法定义中指定方法的返回值类型
18     // >> TODO Java中一个方法只能有一种返回值,如果不需要返回值则用void表示
19     // >> TODO 如果定义了返回值,则必须使用 return 语句返回方法的返回值,return 是 Java 的关键字
20     // >> TODO 可以认为,返回值必须要能够用来给返回值类型的变量赋值
21     public double calculateProfit(){
22         double profit = soldPrice - purchasePrice;
23         // >> TODO 这个return是代码块里的return,是return所在代码块的最后一个语句
24         if (profit <= 0) {
25             return 0;
26         }
27         //  >> TODO return 语句必须是所在代码块的最后一个语句,否则就是语法错误
28         return profit;
29
30         // >> TODO 一个方法可以有多个返回语句。
31     }
32
33     // >> TODO 返回值如果是基本类型,则要类型完全相同,或者符合类型自动转换规则
34     public double getCurrentCount(){
35         return count;
36     }
37
38     // >> TODO 如果不符合规则,可以使用强制类型转换
39     public int getIntSoldPrice(){
40         return (int) soldPrice;
41     }
42
43 }

发生在代码块里的就留在代码块中,参数和方法的局部变量的数据就会被删除回收。

局部变量:

参数:

 1 // >> TODO 方法的代码可以影响方法之外的数据。我们可以通过指向同一个对象的引用,操作这个对象里的属性
 2         MerchandiseV2 paramRef = littleSuperMarket.merchandises[2];
 3
 4         m.gift = giftBowl;
 5         System.out.println("gift变换大法执行前");
 6         m.describe();
 7         paramRef.describe();
 8         m.changeToTheSameGift(paramRef);
 9         System.out.println("gift变换大法执行后");
10         paramRef.describe();

1 public void changeToTheSameGift(MerchandiseV2 m2) { 2 m2.gift = gift; 3 }

9.this指针

1     public void addCount(int count) {
2         // >> TODO 方法里隐藏着一个this自引用,指向调用这个方法的对象。
3         // >> TODO 使用一个对象调用方法,也叫做在这个对象上调用方法。因为方法可以访问这个对象的值。
4         // >> TODO 访问一个成员变量的完整形态,是"this.成员变量的名字"
5         this.count += count;
6
7         System.out.println("MerchandiseV2的addCount方法使用的对象是:" + this);
8     }

方法访问成员变量都是通过this自引用开始访问的

类通过成员变量和方法描述世界。

  • 方法是java中代码执行的单元,是代码的载体,所有代码,都必须属于某一个方法。
  • 方法是一串语句,加上数据输入this自引用和参数,执行后得到一个返回值,所以使用一个对象调用一个方法,可以叫做调用对象的方法,也可以叫做“在这个对象调用方法(invoke a method on an object)”
  • 方法是类的一部分,不是对象的一部分。每个对象可以给成员变量赋不同的值,但是无法让方法有不同的行为,同理,无论在一个类中定义多少方法,都不会让影响创建一个对象所占用的内存

方法明确属于某一个类

类中的方法是没有前后关系的

10.类的成员变量让自己操作,不能让别的类来作

操作成员变量:

  • 初始化成员变量
  • 简单访问和设置成员变量的值(Java Bean)  java豆子
  • 专有的一些计算逻辑
  • 用类定义成员变量,并把操作成员变量的代码都放在类里,就是封装
 1 package com.geekbang;
 2
 3 import com.geekbang.supermarket.MerchandiseV2;
 4
 5 public class MerchandiseV2DescAppMain {
 6     public static void main(String[] args) {
 7         MerchandiseV2 merchandise = new MerchandiseV2();
 8
 9 //        merchandise.name = "书桌";
10 //        merchandise.soldPrice = 999.9;
11 //        merchandise.purchasePrice = 500;
12 //        merchandise.count = 40;
13 //        merchandise.id = "DESK9527";
14
15         // >> TODO 调用方法,完成对成员变量的操作
16         merchandise.init("书桌", "DESK9527", 40, 999.9, 500);
17
18         merchandise.describe();
19     }
20 }

将内外分开

 1 package com.geekbang.supermarket;
 2
 3 public class MerchandiseV2 {
 4
 5     public String name;
 6     public String id;
 7     public int count;
 8     public double soldPrice;
 9     public double purchasePrice;
10
11     public void init(String name, String id, int count, double soldPrice, double purchasePrice) {
12         this.name = name;
13         this.id = id;
14         this.count = count;
15         this.soldPrice = soldPrice;
16         this.purchasePrice = purchasePrice;
17     }
18
19     // >> TODO 定义方法
20     public void describe() {
21         System.out.println("商品名字叫做" + name + ",id是" + id + "。 商品售价是" + soldPrice
22             + "。商品进价是" + purchasePrice + "。商品库存量是" + count +
23             "。销售一个的毛利润是" + (soldPrice - purchasePrice));
24     }
25
26     // >> TODO 定义方法
27     public double calculateProfit() {
28         double profit = soldPrice - purchasePrice;
29 //        if(profit <= 0){
30 //            return 0;
31 //        }
32         return profit;
33     }
34
35     public double buy(int count) {
36         if (this.count < count) {
37             return -1;
38         }
39
40         return this.count -= count;
41     }
42 }

原文地址:https://www.cnblogs.com/JCcodeblgos/p/11410757.html

时间: 2024-10-09 14:30:12

java学习 零基础的相关文章

初学者福利:java从零基础到真正大型企业的项目实战开发学习资源

乡亲们,快来围观啊,java初学者福利java从零基础到真正大型企业的项目实战开发学习资源合集,不必再花时间网上找了,精彩不容错过,以下是学习内容截图(更多精彩稍后推出,最新课程请加群之后,查看群公告): 下载链接: http://pan.baidu.com/s/1o6E8zhC,下载密码请加QQ群435604457.加群验证:java

Java学习:二 基础

2014 - 5 - 22 上午 Java对大小写敏感. 点号(.)用于调用方法,Java的能用语法是: object.method(parameters); Java中的常量声明使用final关键字.且仅能赋值一次.习惯上,常量名大写. 可使用static final 定义一个类常量,以便在一个类中的多个方法中使用. 类常量定义在main方法外部,以便同一类其它方法可以使用.若使用public关键字,则其它类的方法也可以使用此常量. 字符串: Java中,允许使用+号拼接两个字符串. Java

大数据系统学习零基础入门到精通加项目实战2017最新全套视频教程

38套大数据,云计算,架构,数据分析师,Hadoop,Spark,Storm,Kafka,人工智能,机器学习,深度学习,项目实战视频教程 视频课程包含: 38套大数据和人工智能精品高级课包含:大数据,云计算,架构,数据挖掘实战,实时推荐系统实战,电视收视率项目实战,实时流统计项目实战,离线电商分析项目实战,Spark大型项目实战用户分析,智能客户系统项目实战,Linux基础,Hadoop,Spark,Storm,Docker,Mapreduce,Kafka,Flume,OpenStack,Hiv

我JAVA几乎零基础,可以学好大数据吗?

java与大数据的关系你应该明确一下.学习大数据一般要先学java,但并不代表要将java的所有内容都学习,只要学习与大数据相关的知识点就可以.下面是关于学习大数据的一些知识点,你可以大致了解一下,希望对你有所帮助.学习大数据的两大基础就是JAVA和Linux,学习顺序不分前后.需要同时掌握,才可以继续大数据课程的学习.Java:大家都知道Java的方向有JavaSE.JavaEE.JavaME,学习大数据要学习那个方向呢?只需要学习Java的标准版JavaSE就可以了,像Servlet.JSP

Java学习笔记——基础篇

Tips1:eclipse中会经常用到System.out.println方法,可以先输入syso,然后eclipse就会自动联想出这个语句了!! 学习心得: *初始化 *包.权限控制 1.包(package)概念的引入是为了防止类名冲突.package语句要作为java源文件的第一条语句. 2.两个类在同一个包中,可以相互调用:两个类在不同的包中,若想引用则必须通过import语句导入,格式为:import 包名.子包名.类名. 3.如果在程序中同时导入了两个包的同类名,则在使用时必须明确的写

java学习日记-基础-随机数组的求余运算

时间是2017年5月6日,青年节刚过,坐标上海,沪漂2个月. 就这样简短地开始吧.                                by:slowcity [案例分析1] 要求定义一个int 型数组a,包含100 个元素,保存100个随机的4 位数.再定义一个int 型数组b,包含10 个元素.统计a 数组中的元素对10 求余等于0 的个数,保存到 b[0]中:对10 求余等于1 的个数,保存到b[1]中,--依此类推 一般看到这类的最基本的思路:1先建立一个含数组存随机四位数 2

Java学习---面试基础知识点总结

Java中sleep和wait的区别 ① 这两个方法来自不同的类分别是,sleep来自Thread类,和wait来自Object类. sleep是Thread的静态类方法,谁调用的谁去睡觉,即使在a线程里调用b的sleep方法,实际上还是a去睡觉,要让b线程睡觉要在b的代码中调用sleep. ② 锁: 最主要是sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法. sleep不出让系统资源:wait是进入线程等待池等待,出让系统资源,其他线程可以占用CPU.一

2.java学习_基础知识(标识符、常量、变量、运算符)

标识符 定义 在程序中我们自定义的一些名称在编程的过程中,经常需要在程序中定义一些符号来标记一些名称,如包名.类名.方法名.参数名.变量名,这些符号被称为标识符. 组成元素 英文大小写字母 数字0~9 下划线_和美元符号$ 规则 不可以以数字打头,如:4student ,×不可以使用java的关键字,如class不能使用严格区分大小写,如Xxx和xxx,是两个变量 原则 见名知意,驼峰命名 规范 掌握包名多个单词组成时,所有单词都小写.举例:xxxyyyzzz类名和接口名多个单词组成时,所有单词

java学习零散基础01

接口里面的一般是用final 修饰的,private的.用来定义一个接口的关键字interface用来实现一个接口的关键字 接口只是声明一组操作规范.  任何类都可以实现它Java语言约定一个类可实现多个接口相当于一个类可以拥有多个父类 接口的用处就是让类通过实现它,来执行一定的功能.实现接口 , 类声明中用implements 接口里面要声明方法,只有声明了的方法在用接口调用时才可以用,这就有了限制,也有了保护,对不同的人群提供不同的接口 口袋<属性>这样就不用强制转型了, ArrayLis