《大数据和人工智能交流》头条号向广大初学者新增C 、Java 、Python 、Scala、javascript 等目前流行的计算机、大数据编程语言，希望大家以后关注本头条号更多的内容。本文作者：软件设计师天涯雨，本作者和在csdn有相同文章。
Java面向对象（一）
一、面向对象的思想
如何将大象装进冰箱？
（1）、面向过程思想：强调的动作、行为的过程
第一步：将冰箱门打开
第二步：将大象放进冰箱
第三步：将冰箱门关上
（2）、面向对象的过程：强调的是对象的本身
例如上例用面向对象的思想先找到冰箱这个实体，那么冰箱本身具有打开、存储和关闭的功能
使用面向对象的好处：
（1）符合人们的思维习惯
（2）将复杂问题简单化
（3）面向对象让曾经在过程中的执行者，变成了对象中的指挥者
Java的思想：一切皆为对象
面向对象的三大特征：
封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)
面向对象举例：如果将对象比作汽车，那么类就是汽车的设计图纸。所以面向对象程序设计的重点是类的设计，而不是对象的设计
日常生活中的对象：
类和对象的关系：类是抽象的，对象是具体的。生活案例：
类是一个图纸 对象是根据该图纸制造多个实物
类是一个模具 对象是使用模具制造的多个铸件
类是汽车，对象就是购买的一辆辆具体的桑塔纳汽车
怎么描述对象？
（1）找到该对象所属类别
（2）找到该对象的特征（属性）
（3）找到对象有那些行为
Java定义类的语法格式：
public class 类名
{
//定义属性部分
属性1的类型 属性1;
属性2的类型 属性2;
…
属性n的类型 属性n;
//定义方法部分
方法1;
方法2;
…
方法m;
}
Java定义行为方法的语法为：
<修饰符> <返回类型> <方法名>([< 参数表>]) {
[< 语句>]
}
说明： 修饰符：public,private,protected 等； 返回类型：return语句传递返回值。没有返回值：void
第一个面向对象的程序：
（1）所属类别 GirlFriend
（2）定义属性
和以前定义变量一样
（3）定义行为
行为调用的语法：
对象名.方法名();
属性调用的语法：
对象名.属性
{
String sex;
int age;
float height;
public void work()
{
System.out.println("我的女朋友能工作！");
}
public void study()
{
System.out.println("我的女朋友学习好！");
}
}
public class Test001
{
public static void main(String[] args)
{
GirlFriend lily = new GirlFriend();
lily.work();
lily.sex="F";
lily.age=20;
lily.height=166;
System.out.println("女友年龄："+lily.age);
}
}
注意：一个源文件里面只能有一个带public的类
再例如：
public String type="HP-001";
public void computing()
{
int count=0;
for(int i=100;i<=999;i++)
{
int b=i/100;
int s=i%100/10;
int g=i%10;
if(i==b*b*b+s*s*s+g*g*g)
{
System.out.println("水仙花是："+i);
count++;
}
}
System.out.println("水仙花的个数是："+count+"个");
}
}
注意问题：
1、主类的名称必须和源文件名称保持一致
2、只有主类才能有public
3、只有主类里面才能写main方法
4、类里面不能进行行为的调用
匿名对象：
没有名称的对象叫做匿名对象，例如：
new Car();
New Person();
当对象的方法仅进行一次调用的时候
例如：
public class Computer
{
public String type="HP-001";
public void speaking()
{
System.out.println("计算机可以和人交谈");
}
public static void main(String[] args) {
new Computer().speaking();
String s= new Computer().type;
}
}
二、构造方法
概念：构造对象的方法叫做构造方法
构造方法的使用规则：
（1）构造方法不能有返回值类型
（2）构造方法命名必须和类名保持一致
（3）只要对象一产生，就自动运行
public class Person
{
public Person(){
System.out.println("lily 出生了");
}
public static void main(String[] args) {
new Person();
}
}
有参数构造方法：
public class Person
{
public Person(int age,String name){
System.out.println("lily 出生了 age is:"+age);
System.out.println("lily 出生了 name is:"+name);
}
public void crying(){
System.out.println("crying....");
}
public static void main(String[] args) {
Person lily = new Person(1,"lily");
lily.crying();
}
}
（4）如果该类没有定义任何一个构造方法，那么系统默认一个无参数构造方法
注释：
选中代码Ctrl+/
例如：
public class Person
{
public void crying(){
System.out.println("crying....");
}
public static void main(String[] args) {
Person lily001 = new Person();
}
}
（5）如果类里面定义了有参数构造方法，那么在构造无参数的对象时候，该类必须显式指定无参数
构造方法
例如：下列构造无参数的对象的方法是错误的
public class Person
{
public Person(int age,String name){
System.out.println("lily 出生了 age is:"+age);
System.out.println("lily 出生了 name is:"+name);
}
public void crying(){
System.out.println("crying....");
}
public static void main(String[] args) {
Person lily = new Person(1,"lily");
lily.crying();
Person lily001 = new Person();//错误，应该显式的指定无参数构造方法
}
}
下列是正确的：
public class Person
{
public Person()
{
}
public Person(int age,String name){
System.out.println("lily 出生了 age is:"+age);
System.out.println("lily 出生了 name is:"+name);
}
public void crying(){
System.out.println("crying....");
}
public static void main(String[] args) {
Person lily = new Person(1,"lily");
lily.crying();
Person lily001 = new Person();
}
}
（6）构造方法的作用：可以用来初始化对象的一些属性
示例1：
public class Person
{
public String sex;
public String name;
public Person()
{
sex="Female";
name="lily";
}
public void crying(){
System.out.println("crying....");
}
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.sex);
System.out.println(p.name);
}
}
示例2：
public class Person
{
public String sex;
public String name;
public Person(String _sex,String _name)
{
sex= _sex;
name=_name;
}
public void crying(){
System.out.println("crying....");
}
public static void main(String[] args) {
Person p = new Person("female","lily");
System.out.println(p.sex);
System.out.println(p.name);
}
}
1、构造函数：创建对象时候所用的函数为构造函数，可以对对象进行初始化。
2、一个类中如果没有定义过构造函数，则会有一个默认的空构造函数，如果类中定义了构造函数，那么默认的构造函数就没有了
3、构造函数和一般函数的区别
（1）构造函数：对象创建时候调用，并对对象初始化
一般函数：对象创建后，需要时候才调用
（2）构造函数：对象创建时，只调用一次
一般函数：对象创建后，可以多次调用
三、自定义方法
带static的方法不是对象的行为
该行为调用的语法：
类名.方法名();
示例：
public class Computer {
public static void computing()
{
int count = 0; //定义水仙花数的个数
for(int i=100;i<=999;i++)
{
int b = i/100; //取得百位数
int s = i%100/10; //取得十位数
int g = i%10; //取得个位数
if(i==g*g*g+s*s*s+b*b*b)
{
count++; //每次符合水仙花数条件，则x+1;
System.out.println(i+" "); //输出符合条件的数
}
}
System.out.println("水仙花数总共有"+count+"个"); //输出水仙花数的总数
}
public static void main(String[] args)
{
Computer.computing();
}
}
（1）无参数的、无返回值的方法
语法：
修饰符 void 方法名()
{
}
调用的语法：
先生成对象-->对象.方法名();
示例：
public class Computer {
public void display()
{
int count = 0; //定义水仙花数的个数
for(int i=100;i<=999;i++)
{
int b = i/100; //取得百位数
int s = i%100/10; //取得十位数
int g = i%10; //取得个位数
if(i==g*g*g+s*s*s+b*b*b)
{
count++; //每次符合水仙花数条件，则x+1;
System.out.println(i+" "); //输出符合条件的数
}
}
System.out.println("水仙花数总共有"+count+"个"); //输出水仙花数的总数
}
public static void main(String[] args)
{
Computer c1 = new Computer();
c1.display();
}
}
（2）无参数的、有返回值的方法
语法：
修饰符 返回值类型[int、float、String..] 方法名()
{
return int、float、String..;
}
调用的语法：
a 先生成对象
b 数据类型 变量=对象.方法名();
示例：
public class Computer {
public int display()
{
int count = 0; //定义水仙花数的个数
for(int i=100;i<=999;i++)
{
int b = i/100; //取得百位数
int s = i%100/10; //取得十位数
int g = i%10; //取得个位数
if(i==g*g*g+s*s*s+b*b*b)
{
count++; //每次符合水仙花数条件，则x+1;
System.out.println(i+" "); //输出符合条件的数
}
}
return count;
}
public static void main(String[] args)
{
Computer c1 = new Computer();
int num=c1.display();
System.out.println("水仙花数总共有"+num+"个"); //输出水仙花数的总数
}
}
（3）有参数的、无返回值的方法
语法：
修饰符 void 方法名(类型1 参数1,类型2 参数2...)
{
}
调用的语法：
a 先生成对象
b 对象.方法名(值1,值2...);
示例：
public class Machine {
public void makeJuice(String materials)
{
System.out.println("榨"+materials+"汁");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Machine machine = new Machine();
machine.makeJuice("apple");
machine.makeJuice("plum");
machine.makeJuice("watermelon");
machine.makeJuice("strawberry");
}
}
（4）有参数的、有返回值的方法
语法：
修饰符 返回值类型[int、float、String..] 方法名(类型1 参数1,类型2 参数2...)
{
return int、float、String..;
}
调用的语法：
a 先生成对象
b 类型 变量=对象.方法名(值1,值2...);
示例：
public class Machine {
public String makeJuice(String materials)
{
return "榨"+materials+"汁";
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Machine machine = new Machine();
String apple=machine.makeJuice("apple");
String plum=machine.makeJuice("plum");
String watermelon=machine.makeJuice("watermelon");
String strawberry=machine.makeJuice("strawberry");
System.out.println(apple);
System.out.println(strawberry);
}
}
（5）返回值是引用数据类型
示例：
public class Computer {
public String type;
public String maker;
}
public class Machine {
public Computer makeProgram()
{
Computer c=new Computer();
c.type="HP-001";
c.maker="惠普";
return c;
}
public static void main(String[] args) {
Machine machine = new Machine();
Computer computer=machine.makeProgram();
System.out.println(computer.maker);
}
}
（6）参数是引用数据类型
示例：
public class Machine {
public void makeProgram(Computer c)
{
System.out.println("该计算机的型号是："+c.type);
System.out.println("该计算机的厂商是："+c.maker);
}
public static void main(String[] args) {
Machine machine = new Machine();
Computer ccc=new Computer();
ccc.type="ThinkPad-T430";
ccc.maker="lenovo";
machine.makeProgram(ccc);
}
}
Java面向对象（二）
一、匿名对象
直接new
语法：
new 类();
示例：
public class Business
{
public void show()
{
System.out.println("This is show");
}
public static void main(String[] args)
{
new Business().show();
}
}
二、全局变量和局部变量
全局变量：属性就是全局变量又叫成员变量
局部变量：定义在大括号内的变量就是局部变量
成员变量和局部变量的区别
1、作用域不同
局部变量的作用域仅限于定义它的方法或者代码块
成员变量的作用域在整个类内部都是可见的
2、初始值不同
Java会给成员变量一个初始值
引用数据类型：null
char '\u0000'
int 0
float 0.0f;
double 0.0d;
long 0L
boolean false
Java不会给局部变量赋予初始值
3、在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量
4、两类变量同名时，局部变量具有更高的优先级
5、他们在内存中存在的区域不一样
成员变量存在于堆内存的对象中
局部变量存在于栈内存的方法中
6、有关初始值的区别
成员变量都有默认的初始值
局部变量没有默认的初始值，定以后必须给初始值
三、方法和方法之间的调用
1、对象本身的普通方法
(1)类内部的方法
直接调用
示例：
public class Machine {
public void show()
{
test();
System.out.println("This is show");
}
public void test()
{
System.out.println("This is test");
}
public static void main(String[] args) {
Machine m = new Machine();
m.show();
}
}
（2）不同类之间的方法
首先生成对方个实例，通过实例调用
public class Machine {
public void show()
{
B b=new B();
b.test();
System.out.println("This is show");
}
}
class B{
public void test()
{
System.out.println("This is test");
}
}
2、带static的方法
(1)static方法调用static方法
直接调用
public class Machine
{
public static void show()
{
System.out.println("This is show");
}
public static void main(String[] args) {
show();
}
}
（2）非static方法调用static方法
可以直接调用
public class Machine
{
public static void show()
{
System.out.println("This is show");
}
public void test()
{
show();
}
}
（3）static方法调用非static方法
不能直接调用，必须经过实例化
public class Machine
{
public static void show()
{
Machine m=new Machine();
m.test();
}
public void test()
{
System.out.println("This is show");
}
}
四、对象在内存中的体现
为了对数据方便的管理就好像对房间进行方便管理一样，我们内存划分区域。对内存区域的划分历来有争议，这里参考些比较有权威的资料给大家解释下。对于开发人员来说一般我们将内存划分为栈、堆、静态共享区、方法区等
栈：
存放：局部变量
先进后出，自下而上存储
方法执行完毕，自动释放空间
堆：
存放new出来的对象
需要垃圾回收器来回收
静态共享区：
存放： static变量等
1、对象的产生
例如：有Person类
public class Person
{
int age;
void show()
{
System.out.println(“I am “ + age);
}
}
Person p1 = new Person();执行完后的内存状态
当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的都是变量类型都是引用类型，如上面的Person及前面讲过的数组。
2、对象的使用
创建新的对象之后我们就可以使用“ 对象名.对象成员 ”的格式来访问对象的员
class Test
{
public static void main(String[] args)
{
Person p1 = new Person();
Person p2 = new Person();
p1.age = 20;
p1.show();
p2.show();
}
}
上述代码运行的内存示意图如下：
3、对象的回收
下面举2个例子详细说明对象的生命周期：
例-1：
public class Test
{
public static void change(int i)
{
i=1;
}
public static void main(String args[]) {
int i=0;
change(i);
System.out.println(i);
}
}
说明：
i=0进栈，然后 i=0出栈，i=1,i=1出栈，方法运行完毕，出栈，方法默认含有return结束方法体，声明周期结束，这时候只有主方法i=0
例-2：
public class Test
{
int i=10;
public static void change(Test t)
{
t.i=100;
}
public static void main(String args[])
{
Test t=new Test();
t.i=1000;
change(t);//将此代码改为change(new Test())结果有什么不同
System.out.println(t.i);
}
}
说明：
上述操作mian方法进栈；对象t进栈，并且在堆内存分配空间；对象t有个成员i,初始化为0，系统将10赋予I;这时候change方法进栈，change方法的t进栈，并指向堆中同一个地址0x00ff（假设值）这时候将i修改为100;方法出栈，内存中只剩下对象t
总结：
1、堆 ：new 出来的数据à对象
2、栈 ： 局部变量的数据
3、数据共享区 ：static
注意：凡是new 出来的东西在堆区，是一个个新的对象。例如：
1、System.out.println(new Goods()==new Goods());输出false
2、 System.out.println(new Goods());
System.out.println(new Goods());
输出hashCode不一样
test002.Goods@18a992f
test002.Goods@4f1d0d
3、下列5个对象不是同一个对象
for(int i=0;i<5;i++)
{
Goods lily=new Goods();
System.out.println(lily);
}
可以根据打印的对象的值来判断
test002.Goods@18a992f
test002.Goods@4f1d0d
test002.Goods@1fc4bec
test002.Goods@dc8569
test002.Goods@1bab50a
栈空间举例：
public class Goods
{
public static void main(String[] args)
{
Recursion r=new Recursion();
long num=r.fac(5);
System.out.println(num);
}
}
public long fac(int n){
if(n==1){
return 1;
}else{
return n*fac(n-1);
}
}
}
Java面向对象（三）
一、this关键字
（1）什么是this
this一般出现在方法的声明里面。this指的是当前对象，即代表使用该方法对象的那个引用，所以那个对象调用了this所在函数，this就代表那个对象
（2）this的用处
1、使用this处理方法中成员变量和局部变量、参数重名的情况，可以使程序更清晰
class Person
{
private String id;//身份证号
private String name;//姓名
//函数体里面不能写成name=name，所以使用this来区分成员变量和参数
Person(String name) {
this.name=name;
}
public void speak()
{
System.out.println(name+"在说话！");
}
public static void main(String args[])
{
Person p=new Person("张三");
p.speak();
}
}
2、必须指出当前方法的对象是谁的时候要使用this
class Person
{
private String id;//身份证号
private String name;//姓名
//可以不显式使用this,但是当方法中的参数名和类的成员变量名一样时，可以使程序更清晰
public void setSpeak(String name)
{
this.name=name;
}
public String getSpeak()
{
return this.name;
}
public static void main(String args[])
{
Person p1=new Person();
p1.setSpeak("张三");
System.out.println(p1.getSpeak()+"在说话！");
Person p2=new Person();
p2.setSpeak("李四");
System.out.println(p2.getSpeak()+"在说话！");
}
}
3、在构造函数中调用其他构造函数。但是只能放在构造函数的第一行，因为初始化的动作要先执行
class Person
{
String name;
int age;
String sex;
public Person()
{
System.out.println("构造器Person()被调用");
sex ="Male";
System.out.println("name="+name+" age="+age+" sex="+sex);
}
public Person(String theName)
{
//调用构造器Person()
this();
System.out.println("构造器Person(String theName)被调用");
this.name = theName;
System.out.println("name="+name+" age="+age+" sex="+sex);
}
public Person(String theName,int theAge)
{
//调用构造器Person(String theName)
this(theName);
System.out.println("构造器Person(String theName,int theAge)被调用");
age = theAge;
System.out.println("name="+name+" age="+age+" sex="+sex);
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String getSex()
{
return sex;
}
}
4、将当前对象作为参数传递给其它方法或构造器
class Account
{
int accountId = 100;
public Account createAccount()
{
accountId ++;
return this;
}
public int getAccountId()
{
return accountId;
}
public static void main(String[] args)
{
Account a= new Account();
System.out.println("账号是："+a.createAccount().getAccountId());
}
}
二、包package和import关键字
1、为什么需要package?
为了解决类之间的重名问题；为了便于管理类：合适的类位于合适的包
2、package怎么用?
通常是类的第一句非注释性语句。
包名：域名倒着写即可，再加上模块名，并与内部管理类。
3、注意事项：
写项目时都要加包，不要使用默认包。com.gao和com.gao.car，这两个包没有包含关系，是两个完全独立的包。只是逻辑上看起来后者是前者的一部分
4、JDK中的主要包
java.lang
包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
java.awt
包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
java.net
包含执行与网络相关的操作的类。
java.io
包含能提供多种输入/输出功能的类。
java.util
包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数
5、为什么需要import?
如果不适用import，我们如果用到其他包的类时，只能这么写：java.util.Date，代码量太大，不利于编写和维护。通过import可以导入其他包下面的类，从而可以在本类中直接通过类名来调用
import怎么使用?
import java.util.Date;
import java.util.*; //导入该包下所有的类。会降低编译速度，但不会降低运行速度。
注意要点：
java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
如果导入两个同名的类，只能用包名+类名来显示调用相关类：
java.util.Date date = new java.util.Date();
静态导入的作用：用于导入指定类的静态属性
JDK5.0后增加！
import static：
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性
然后，我们可以在程序中直接使用：System.out.println(PI);
三、static关键字
（1）在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，对于该类的所有对象来说，staitic成员变量只有一个
（2）用static声明的方法为静态方法，在调用该方法时候，不会将对象的引用传递给它，所以在static方法中不可以访问非static成员，也就是说由于静态方法不再针对于某个对象的调用，所以不能访问非静态成员
被static修饰的成员有如下特点：
1、随着类的加载而加载
2、优先于对象存在
3、被所有对象共享
4、可以用类名直接调用：类名.static成员；类名.方法名()
注意：静态方法中不能写this、super关键字
静态变量和成员变量区别
（1）生命周期不同：成员变量随着对象的创建而存在，随着对象的销毁而释放静态变量随着类的加载而存在，随着类的消失而消失
（2）调用方式不一样：成员变量只能被类对象调用，静态变量可以被对象调用，也可以用类名调用
（3）成员变量是类实例化的变量，静态变量为类变量
（4）数据存储位置不同
成员变量存储在堆内存的对象中，是对象的特有数据；静态数据存储在内存数据共享区
静态代码：
{
static {……..}//静态代码块
}
（1）、其特点为随着类的加载而执行，而且只执行一次
public class StaticTest
{
static
{
System.out.println("this is static demo!");
}
void test()
{
System.out.println("this is test!");
}
public static void main(String[] args)
{
new StaticTest().test();
new StaticTest().test();
}
}
其作用为类的成员初始化（有的类全是静态成员方法）
public class StaticTest1
{
static int num;
static
{
int num=0;
}
public static void f1()
{
System.out.println(num);
}
public static void f2()
{
System.out.println(num+1);
}
}
下列代码输出什么结果？为什么？
public class Demo {
public static String sname;
static{
sname="lily";
System.out.println(sname);
}
public Demo()
{
System.out.println("这是构造方法");
}
public static void main(String[] args) {
new Demo();
}
}
先有类，后有对象
补充知识点：代码块
public class Demo {
{
System.out.println("这是代码块");
}
public Demo()
{
System.out.println("这是无参数构造方法");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
new Demo();
}
}
总结：static > 代码块 > 构造函数；static不能修饰局部变量；static方法里面不能有this因为static和this属于不同的内存区域，this是对象没有实例化它不存在
《大数据和人工智能交流》的宗旨
1、将大数据和人工智能的专业数学：概率数理统计、线性代数、决策论、优化论、博弈论等数学模型变得通俗易懂。
2、将大数据和人工智能的专业涉及到的数据结构和算法：分类、聚类 、回归算法、概率等算法变得通俗易懂。
3、最新的高科技动态：数据采集方面的智能传感器技术；医疗大数据智能决策分析；物联网智慧城市等等。
根据初学者需要会有C语言、Java语言、Python语言、Scala函数式等目前主流计算机语言。
根据读者的需要有和人工智能相关的计算机科学与技术、电子技术、芯片技术等基础学科通俗易懂的文章。
