java面向对象 面向对象的语法 收藏 0

java的面向对象到底是什么意思？

Java 是一门面向对象的编程语言，以前听过这样一句话：一切皆对象。可见，对象在 Java 语言中是非常非常重要。那么，Java 中的对象到底是怎么回事儿呢？

在 Java 中，对象通常包括实例变量和方法两种属性。

实例变量是对象本身已知的事物，它代表对象的一种状态（数据），并且同一个类型的多个对象都独立地拥有这些状态。从这个角度来看，我们也可以把对象看作是类的一个实例。

方法就是对象可以执行的动作。通常我们在构造一个类时，我们除了要初始化类的状态，我们还要构造出可以操作这种状态的方法。

举个例子：

需要注意的是，虽说 Java 中一切皆对象，但是几乎所有对象都是通过某个类的模型构造出来的。也就是说，类和对象是不可分割的，不过类和对象还是有区别的。

那么，类和对象究竟有什么不同呢？

类不是对象，类是用来构造对象的。当我们通过类 new 出该类的一个实例（对象）时，类就需要告诉虚拟机要如何创建我这个类的对象。我们可以将类视为一张设计图纸，在创建对象时，虚拟机不是时按照图纸的规定把实物做出来而已。

举个例子，当我们有一个按钮类，我们就可以通过这个按钮类创建出很多大小、颜色、形状各不相同的按钮。

我们有必要了解的是，程序代码都是 main() 方法中是不合适的。简单的测试用例可能无伤大雅，但是一旦程序复杂起来，那么势必是需要让对象和对象之间相互交互的。在这种需要对象间交互的情形，要是再把所有代码都放在 main() 方法中，程序的任何一点小改动都需要重新测试整套代码，要是代码量很大，这个过程将是灾难性的。

实际上，程序都放在 main() 方法中不是面向对象编程的思想，而 Java 语言是面向对象的语言。所以，我们在使用 Java 进行编程时，拥有面向对象编程的思想是异常重要的。

以我现在的理解，我能够想到的就是，无论什么时候编写 Java 程序，我们就刻意将所有东西对象化。比如，桌子是对象、电影是对象、狗是对象、一本书是对象…然后再去考虑这些对象都有哪些已知的状态，比如，桌子是方的、电影时长 120 min、狗毛是黄色的…除此之外，还要考虑这些对象都能够干什么，就像上面那个 dog 对象，这个 dog 对象就能 bark （吠）。

所有对象的创建都发生在堆内存（关于内存模型，后面我们找机会详细聊下）中，并且这个堆是可回收垃圾的对内存。Java 的垃圾回收机制也是我们后面需要熟悉的，总的来说，Java 会根据对象的大小来分配堆内存空间。比如说，拥有 15 个实例变量的对象所获分配的空间就可能比只拥有 2 个实例变量的对象所获空间大。Java 对象是被使用完成后，Java 的垃圾回收机制会自动帮助我们清理内存。

大体上是这样的，当某个对象被 Java 虚拟机察觉到不会再被使用了，这时 Java 虚拟机会将这个对象标记为是可回收的。一旦内存紧张，垃圾收集器就会开始工作，清理垃圾，以便腾出内存空间投入再使用。

总结一下：

1、Java 是面向对象的程序语言，面向对象编程思想是非常重要的

2、真正的 Java 程序都是对象间的交互

3、面向对象设计拓展程序功能无需改动之前已经测试好的代码

4、所有的 Java 程序都定义在类中，类是对象的设计图纸

5、对象都有实力变量（状态）和方法（可执行动作）两种属性

这次只是一个简单的介绍，如果觉得对你有帮助到，记得点个赞再走哟~

Java面向对象详细总结

《大数据和人工智能交流》头条号向广大初学者新增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）定义行为

行为调用的语法：

对象名.方法名();

属性调用的语法：

对象名.属性

class GirlFriend

{

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的类

再例如：

class NotePad{

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@1baa

栈空间举例：

public class Goods

{

public static void main(String[] args)

{

Recursion r=new Recursion();

long num=r.fac(5);

System.out.println(num);

}

}

class Recursion{

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）数据存储位置不同

成员变量存储在堆内存的对象中，是对象的特有数据；静态数据存储在内存数据共享区

静态代码：

class Test

{

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函数式等目前主流计算机语言。

根据读者的需要有和人工智能相关的计算机科学与技术、电子技术、芯片技术等基础学科通俗易懂的文章。

java基础教程-面向对象（一）

一、面向对象

1.1 java键盘输入

1.1.1这种方法我认为是最简单，最强大的，就是用Scanner类

这段代码已经表明，Scanner类不管是对于字符串还是整型数据或者float类型的变量，只需做一点小小的改变，就能够实现功能!无疑他是最强大的

1.1.2

1.2．数组

定义数组 int a=new int [10][10];

1.3．java变量命名规则

1、 类名：每个单词首字母大写，例UserName

2、 方法名和变量名：第一个单词首字母小写，其他单词首字母大写

例：getInfor，getInfor

注：类方法的第一个单词必须是动词

构造方法（用来完成对对象的初始化）：名字必须与类的名字相同

3、 包名：全部小写，例：example

4、 常量：所有字母全部大写，如果多个单词组成，通常用_连接

例：MIN_VALUE，PI

1.4．Java内存解析

形参和局部变量在栈中分配内存空间 ，运行完自动释放，堆中的内存程序员释放，分析内存解析时，要从main开始一步一步分析。在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针!

静态变量（static）存放在数据区

new创造对象，会直接执行构造函数，

首先我们先来讲解一下内存中的各个区域。

stack（栈）：存放基本类型的数据和对象的引用，即存放变量。

如果存放的事基本类型的数据（非静态变量），则直接将变量名和值存入stack中的内存中；

如果是引用类型，则将变量名存入栈，然后指向它new出的对象（存放在堆中）。

heap（堆）：存放new产生的数据。

data segment：分为静态域和常量域。

静态域：

存放在对象中用static定义的静态成员（即静态变量，同理，如果该静态变量是基本类型则将变量名和值存入静态域，如果是引用类型则指向new出的对象）。

常量池：

常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。除了包含代码中所定义的各种基本类型（如int、long等等）和对象型 （如String及数组）的常量值(final)还包含一些以文本形式出现的符号引用，比如：类和接口的全限定名；字段的名称和描述符；方法和名称和描述符。

注：大家要注意String类型不是基本数据类型，所以它可以创建对象，并且它的值是放在常量池中的。

1.5．Static

每new一个对象，成员变量都会赋予新的值，而static成员变量是唯一的，固定不变的，而且对所有成员共享，访问的静态变量占用统一块内存。

1.6.包

包的命名 对于公司， com.company.lksk.sk

调用包 用inport 包名.* (调用包下的所有类)

或 import 包名.类名 （调用特定类）

调用时 调用的包必须与程序在相同目录下，而且类必须是/com/company/lksk/sk/文件夹下 或者class文件的最上层包的父目录（com文件的父目录）位于classpath下

执行一个类，需要写全包名，即java com.company.lksk.sk.Dog

在jdk中的jre/lib文件夹中rt.jar，包含java自带的各种类，而Java.lang包中的类可以直接使用(包括System.class String.class等)，不需要import，其余均需要import

生成jar包，目录调至class文件最上层包的父目录，执行jar –cvf test.jar *.*（jar包的名字）

1.7． Java SE EE ME区别：

Java SE=Java Standard Edition

Java EE=Java Enterprise Edition

Java ME=Java Mobile Edition

SE（标准版）主要用于桌面程序,控制台开发(JFC)

EE（企业版）企业级开发(JSP,EJB)：网站开发和基于 b/s模式的编程

ME（微缩版）嵌入式开发(手机,小家电)：手机软件游戏编程

1. Java SE（Java Platform，Standard Edition）。Java SE 以前称为 J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类，并为 Java Platform，Enterprise Edition（Java EE）提供基础。

2. Java EE（Java Platform，Enterprise Edition）。这个版本以前称为 J2EE。企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端 Java 应用程序。Java EE 是在 Java SE 的基础上构建的，它提供 Web 服务、组件模型、管理和通信 API，可以用来实现企业级的面向服务体系结构（service-oriented architecture，SOA）和 Web 2.0 应用程序。

3. Java ME（Java Platform，Micro Edition）。这个版本以前称为 J2ME。Java ME 为在移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）上运行的应用程序提供一个健壮且灵活的环境。Java ME 包括灵活的用户界面、健壮的安全模型、许多内置的网络协议以及对可以动态下载的连网和离线应用程序的丰富支持。基于 Java ME 规范的应用程序只需编写一次，就可以用于许多设备，而且可以利用每个设备的本机功能。

Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。

相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同，第二次生成的随机数字也完全相同。这点在生成多个随机数字时需要特别注意。

Random类中的方法比较简单，每个方法的功能也很容易理解。需要说明的是，Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率是均等的。下面对这些方法做一下基本的介绍：

a、public boolean nextBoolean

该方法的作用是生成一个随机的boolean值，生成true和false的值几率相等，也就是都是50%的几率。

b、public double nextDouble

该方法的作用是生成一个随机的double值，数值介于[0,1.0)之间。

c、public int nextInt

该方法的作用是生成一个随机的int值，该值介于int的区间，也就是-231到231-1之间。

如果需要生成指定区间的int值，则需要进行一定的数学变换，具体可以参看下面的使用示例中的代码。

d、public int nextInt(int n)

该方法的作用是生成一个随机的int值，该值介于[0,n)的区间，也就是0到n之间的随机int值，包含0而不包含n。

如果想生成指定区间的int值，也需要进行一定的数学变换，具体可以参看下面的使用示例中的代码。

e、public void setSeed(long seed)

该方法的作用是重新设置Random对象中的种子数。设置完种子数以后的Random对象和相同种子数使用new关键字创建出的Random对象相同

方法举例：

Random r = new Random；

生成[1,2.5)区间的小数：double d3 = r.nextDouble * 1.5 + 1;

生成[-3,15)区间的整数：int n4 = r.nextInt(18) – 3;

多态实际上就是就是，调用方法时，如果方法重写了，实际当中调用哪个方法，要看你new的对象是什么。

动态绑定是指在执行期间（而非编译期间）判断所引用对象的实际类型，根据实际类型调用其相应的方法。

多态的三个必要条件：1、要有继承2、要有重写3、父类引用指向子类对象。当三个条件满足，调用父类中的重写的方法时，实际上new的什么对象，就调用该对象的方法。

1.10．abstract类/object类

abstrcat抽象方法是用来重写的，本身只做定义，在子类中重写，抽象方法必须位于抽象类中。抽象类必须被继承，抽象类不能实例化；抽象方法必须被重写，抽象方法只需声明，不需实现。子类继承抽象类时，必须重写抽象类中的方法。

object 类中的equals函数必须是指向同一引用时，才会返回true，所以一般要重写equals函数。

1.11．final

final 的变量值不能改变，final的方法不能重写，final的类不能继承

1.12．接口

接口是抽象类和常量定义的集合，实际上接口是一种特殊的抽象类，这种抽象类只包含常量方法的定义，而没有变量和方法的实现。接口方法的实现必须用class去implements

接口中声明的属性只能是public static final（不管你写不写），方法只能是抽象方法（不管你写不写），而且必须是public。

接口的实现用implements

类之间只能单继承，一个子类只能继承一个父类，而一个类可以实现多个无关的接口，且多个无关的类可以实现同一个接口。

例：class Teacher implements Singer，Painter{}

class Teacher extends School implements Singer，Painter{}

当接口继承另一个接口时，实现接口的类，必须重写两个接口中所有的方法。

本文作者及来源:Renderbus瑞云渲染农场https://www.renderbus.com