Java入门学习

Java语言

最近由于项目需要，重新学习了一下Java语言，下面也是自己Java语言入门学习的笔记：

java语言特点：面向对象的设计，特性有三点 封装、继承、多态

java语言是两种类型的集合：编译型、解释型

java和c和c++的区别：

（1）垃圾回收机制：可以自动进行垃圾回收，开发者不用去关心内存管理问题；

（2）不再使用指针，用this关键字替代指针的功能；

（3）单继承，可以用接口实现多继承；

（4）功能强大，跨平台；

（5）java虚拟机JVM机制屏蔽了底层运行平台的差别，实现“一次编译，处处运行”（跨平台）；

Java运行环境的三项主要功能：

加载代码：由class loader完成；

检验代码：由bytecode verifier完成；

执行代码：由runtime interpreter完成；

Java开发环境搭建步骤：

（1）安装JDK

（2）需要注意：在安装JDK的时候不要选择中文目录，和不要有一些非法字符

（3）配置环境变量，就是将你安装的JDK的路径添加到环境变量，如C：\Java\jdk1.7.0_15\bin （一定要指到bin目录）

（4）检查java环境是否安装成功，在命令框输入以下命令：

java -version 用于查看JDK版本

java 检查运行环境

javac 检查编译环境

一般开发java的工具就是eclipse，关于eclipse的使用步骤网上有很多。

以上就是java开发的背景和开发的环境，下面正式开始写java代码。

1. 新一个hello word 的java代码：

package com.fs.helloworld;

public class Helloworld

{

public static void main(String[] args) {

System.out.println("hollo world");

}

}

这就是一个最简单的java代码，和C语言一样这个main方法就是代码的入口，编译执行这段代码会打印hollo world。

java语言是面向对象的设计，最重要的概念之一就是类（class），我这里介绍的也是围绕class展开的，罗列一下学习java基础的知识点就是：

匿名对象

构造方法

对象的比较

this使用

类的基本形式 static使用

构造方法的私有

对象数组的使用

内部类

继承的基本概念

抽象类

Object类

类的继承 final关键字

接口（interface）

对象的多态性

匿名内部类

一、匿名对象：

class Person

{

private String name = "张三" ;

private int age = 25 ;

public String talk()

{

return "我是："+name+"，今年："+age+"岁" ;

}

}

public class TestNoName

{

public static void main(String[] args)

{

System.out.println(new Person().talk());

}

}

代码中红色部分就是用的匿名对象，一看就便知

二、构造方法：

方法名和类名一致，可以有参也可以无参。

构造方法是在创建对象的时候自动执行

TestConstruct.java

class Person

{

public Person() // Person类的构造方法

{

System.out.println("public Person()") ;

}

}

public class TestConstruct

{

public static void main(String[] args)

{

Person p = new Person() ;

}

}

输出结果为：public Person()

Person() 方法就是person的构造方法。

构造方法的重载：在Java里，不仅普通方法可以重载，构造方法也可以重载。只要构造方法的参数个数不同，或是类型不同，便可定义多个名称相同的构造方法。

例如上面的person类：

class Person

{

public Person() // Person类的构造方法

{

System.out.println("public Person()") ;

}

public Person(String n,int a)

{

name = n ;

age = a ;

System.out.println("public Person(String n,int a)") ;

}

}

当我在创建person的对象时传入对应的参数，就会自动执行Person(String n,int a)方法

如：Person p = new Person("张三",25);

三、对象的比较

这里有两种比较方法 “==”和“equals”

“==”用于比较两个对象的内存地址值是否相等，equals() 比较两个对象的内容是否一致

四、super、this的使用

super使用在父类对象的引用中，一般都是直接指向父类的属性和方法

this指向的是本类的属性和方法

在子类的构造方法中，如果没有写super()，系统会默认生成一个super（）指向

父类的不带参数的构造方法。

如果在子类的构造方法的调用中，不管父类对象生成在什么位置，会优先执行父类

对应的构造方法（包括带参数和不带参数的），然后再继续执行子类构造方法中剩下的代码。

class Person

{

private String name;

private int age;

public Person(String name,int age)

{

this.name = name;

this.age = age;

}

public String talk()

{

return "我是："+name+"，今年："+age+"岁";

}

}

public class TestJavaThis

{

public static void main(String[] args)

{

Person p = new Person("张三",25);

System.out.println(p.talk());

}

}

输出结果：

我是：张三，今年：25岁

五、static关键字的使用

用static修饰的变量叫静态变量，用static修饰的方法叫静态方法。可被类的所有实例共享。static对象可以在它的任何对象创建之前访问，无需引用任何对象。

访问：

类名.静态属性

类名.静态方法

六、构造方法的私有

做法就是在当前类的构造方法前加上private修饰，这样就只能在本类中实例化对象，

并在本类中提供一个方法返回本类实例化的对象，方便在本类以外的地方可以得到本类的方法和属性。

这种做法在设计模式中称为单态模式。是优化后的代码结构、编程风格。

范例：

class Person

{

String name;

// 在本类声明一Person对象p，注意此对象用final标记，表示不能再重新实例化

private static final Person p = new Person();

private Person()

{

name = "张三";

}

public static Person getP()

{

return p;

}

}

public class TestSingleDemo2

{

public static void main(String[] args)

{

// 声明一Person类的对象

Person p = null;

p = Person.getP();

System.out.println(p.name);

}

}

输出结果：

张三

七、对象数组的使用

1、声明类类型的数组变量，并用new分配内存空间给数组。

2、用new产生新的对象，并分配内存空间给它

例如，要创建三个Person类类型的数组元素，可用下列的语法：

Person p[] ; // 声明Person类类型的数组变量

p = new Person[3] ; // 用new分配内存空间

创建好数组元素之后，便可把数组元素指向由Person类所产生的对象：

p[0] = new Person ();

p[1] = new Person (); 用new产生新的对象，并分配内存空间给它

p[2] = new Person ();

此时，p[0]、p[1]、p[2]是属于Person类类型的变量，它们分别指向新建对象的内存参考地址。当然也可以写成如下形式：

Person p[] = new Person[3]; // 创建对象数组元素，并分配内存空间

当然，也可以利用for循环来完成对象数组内的初始化操作，此方式属于动态初始化：

for(int i=0;i<p.length;i++）

{

p[i] = new Person();

}

或者采用静态方式初始化对象数组：

Person p[] = {new Person(),new Person(),new Person()}

范例：

class Person

{

String name;

int age;

public Person()

{

}

public Person(String name,int age)

{

this.name = name;

this.age = age;

}

public String talk()

{

return "我是："+this.name+"，今年："+this.age+"岁";

}

}

public class TestObjectArray

{

public static void main(String[] args)

{

Person p[] = {

new Person("张三",25),new Person("李四",30),new Person("王五",35)

};

for(int i=0;i<p.length;i++)

{

System.out.println(p[i].talk());

}

}

}

输出结果：

我是：张三，今年：25岁

我是：李四，今年：30岁

我是：王五，今年：35岁

八、内部类

意思就是在一个类的内部在定义一个类

如：

class Outer

{

int score = 95;

void inst()

{

Inner in = new Inner();

in.display();

}

class Inner

{

void display()

{

System.out.println("成绩: score = " + score);

}

}

}

要注意：

内部类是可以访问外部类的属性。

外部类是无法找到内部类中所声明的属性。

用static声明的内部类则变成外部类，但是用static声明的内部类不能访问非static的外部类属性。

内部类也可以通过创建对象从外部类之外被调用，只要将内部类声明为public

范例：

class Outer

{

int score = 95;

void inst()

{

Inner in = new Inner();

in.display();

}

public class Inner

{

void display()

{

System.out.println("成绩: score = " + score);

}

}

}

public class InnerClassDemo3

{

public static void main(String[] args)

{

Outer outer = new Outer();

Outer.Inner inner = outer.new Inner();

inner.display() ;

}

}

九、类的继承

1.概念：

用extends关键字实现类的继承

如：

class Person

{

String name;

int age;

}

class Student extends Person

{

String school;

}

父类：Person 子类：Student

父类中的方法和属性 被子类所拥有。

注意：在Java中只允许单继承，也就是一个子类只能有一个父类。

2：子类对象的实例化：

范例：

class Person

{

String name;

int age;

//父类的构造方法

public Person()

{

System.out.println("1.public Person(){}");

}

}

class Student extends Person

{

String school;

//子类的构造方法

public Student()

{

System.out.println("2.public Student(){}");

}

}

public class TestPersonStudentDemo1

{

public static void main(String[] args)

{

Student s = new Student();

}

}

输出结果：

1.public Person(){}

2.public Student(){}

从这个例子可以看到，当我们在new子类的对象时，是先掉了父类的构造方法，再掉子类的构造方法。

这里要提的是super关键字：

super主要的功能是完成子类调用父类中的内容，也就是调用父类中的属性或方法。

十、抽象类

用abstract 关键字修饰。

注意：

（1）抽象类不能创建对象（不能被实例化）

（2）抽象方法没有方法体

（3）包含一个抽象方法的类必须是抽象类

（4）抽象方法依赖于继承关系抽象类必须被子类继承才能实现它的作用，

子类如果不是抽象类则必须覆写抽象类中的抽象方法。

（5）不能用final修饰，final不能被继承，而抽象类必须有子类，两者是矛盾的。

（6）抽象类只允许创建其子类，它的抽象方法才能被实现。

十一、Object 类

Object类是所有类的父类。

十二、final关键字

（1）final标记的类不能被继承

（2）final标记的方法不能被子类复写

（3）final标记的变量即为常量，只能赋值一次

十三、接口（interface）

interface 接口名称 // 定义抽象类

{

final 数据类型成员名称 = 常量； // 数据成员必须赋初值

abstract 返回值的数据类型方法名称（参数…）；

}

注意：

（1）继承使用extends关键字，是一种单继承；接口使用interface关键字，可以实现多继承。

（2）接口可以看成是一种特殊的抽象类，不能被实例化

（3）接口中的成员变量默认都是public static final类型（常量），使用时必须初始化

（4）接口中的方法默认都是public abstract 类型（抽象方法）

（5）当实现了某个接口时，它必须实现接口中所有的抽象方法，否则这个类必须定义为抽象类

实现接口：

class 类名称 implements 接口A,接口B // 接口的实现

{

•••

}

范例：

interface Person

{

String name = "张三";

int age = 25;

String occupation = "学生";

// 声明一抽象方法talk()

public abstract String talk();

}

// Student类继承自Person类

class Student implements Person

{

// 复写talk()方法

public String talk()

{

return "学生——>姓名："+this.name+"，年龄："+this.age+"，职业

"+this.occupation+" ！";

}

}

class TestInterfaceDemo1

{

public static void main(String[] args)

{

Student s = new Student();

System.out.println(s.talk());

}

}

输出结果：

学生——>姓名：张三，年龄：25，职业：学生！

程

接口还可以继承

interface 子接口名称 extends 父接口1，父接口2，…

{

•••

}