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：Javajdk1.7.0_15bin （一定要指到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，…
{
•••
}