目录
1. 快速入门
2. 类
3. 成员方法
4. 构造器
5. 单例模式
6. 继承
7. 抽象类
8. 多线程（Thread与Runnable）
1. 快速入门
public class Hello
{
public static void main(String[] args)
{
System.out.println("Hello,World");
}
}
1."public class Hello" 是一个公有的类，类名是Hello，类名与文件名必须保持一致
2."public static void main(String[] args)" 类似C++中的"int main()"，主函数，是程序的入口，内部编写程序主体2. 类
（1）java的类等同于C++中的结构体，先定义一个类，再用这个类去创建变量
// 定义一个猫类
class Cat
{
String name; // 名字
int age; // 年龄
String color; // 颜色
String[ ] master; // 字符串数组类型
}
// 用这个类去创建变量
Cat cat1 = new Cat();
// new Cat() --> 创建一只猫
// Cat cat1 --> 用cat1这个变量来接收，Cat是数据类型。类比结构体创建变量（2）类的使用
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 10;
cat1.color = "白色"；
Cat cat2 = new Cat();
cat2.name = "小红";
cat2.age = 20;
cat2.color = "红色"；
3. 成员方法
（1）相当于C++中的函数，但由于java是面向对象的语言，因此方法是在成员里面的，通过调用成员来调用方法，故称之为成员方法。
（2）方法的定义
class Person
{
String name;
int age;
public void speak()
{
System.out.println("我是一个好人");
}
public void tot1()
{
int s=0;
for (int i=1;i<=10;i++)
s+=i;
System.out.println(s);
}
public void tot2(int n)
{
int s=0;
for (int i=1;i<=n;i++)
s+=i;
System.out.println(s);
}
}
（3）方法的使用
public class Method1
{
public static void main(String[] args)
{
Person p = new Person();
p.speak();
p.tot1();
p.tot2(5);
}
}
（4）有返回值的方法
public class Method2
{
public static void main(String[] args)
{
Person p = new Person();
int ans = p.tot(10,20);
System.out.println(ans);
}
}
class person
{
public int tot(int a,int b)
{
return a+b;
}
}4. 构造器
（1） 介绍
前面在创建一个猫变量时，是先将变量创建好后再给他的姓名年龄属性赋值。使用构造器可以在创建猫这个对象时直接指定其属性。
（2）注意点
· 修饰符可以是public，protected，private
· 构造器没有返回值，也不能加"void"
· 构造器的名字需和类名一致
（3）使用
public class Construct {
public static void main(String[] args)
{
Person1 p = new Person1("张三",10);
System.out.println(p.name+" "+p.age);
}
}
class Person1
{
String name;
int age;
public Person1(String pname,int page) // 形参列表，由主方法传入
{
name = pname; // 初始化变量的属性值
age = page;
}
}5. 单例模式
一. 饿汉式（不论是否需要用到这个变量，都会去创建）
（1）步骤
· 构造器私有化。防止直接new一个对象
· 在类的内部创建对象
· 向外暴露一个静态的方法
（2）实现
public class Single {
public static void main(String[] args)
{
Girlfriend gf = Girlfriend.getInstance();
System.out.println(gf.name);
}
}
class Girlfriend
{
private String name;
private static Girlfriend gf = new Girlfriend("小红"); // 必须加上静态"static"，与下面公有化的"static"相对应
private Girlfriend(String name)
{
this.name = name;
}
public static Girlfriend getInstance() // 向外暴露静态
{
return gf;
}
}二. 懒汉式（需要用到这个变量时才去创建）
public class Single2 {
public static void main(String[] args)
{
Girlfriend gf = Girlfriend.getInstance();
System.out.println(gf.name);
}
}
class Girlfriend2
{
public String name;
private static Girlfriend2 gf; // 声明变量名，但不去创建
private Girlfriend2(String name)
{
this.name = name;
}
public static Girlfriend2 getInstance()
{
if (gf == null) // 多一条判断，该变量是否已经创建过
gf = new Girlfriend2("小红");
return gf;
}
}6. 继承
（1）作用
当不同类之间有大量重复的成员变量和方法时，设置一个父类，包含所有类共同的部分，所有类作为子类继承父类，已经拥有共同部分，只需再添加自己特有的部分即可。
（2）实现
class Student { // 父类
public String name;
public int age;
private double score;
public void setScore(int score)
{
this.score = score;
}
public void Show()
{
System.out.println("学生名 " + name + " 年龄 " + age + " 成绩 " + score);
}
}
class Pupil extends Student // 子类1：小学生
{
public void testing()
{
System.out.println("小学生 " + name + " 正在上课");
}
}
class Gra extends Student // 子类2：大学生
{
public void testing()
{
System.out.println("大学生 " + name + " 正在上课");
}
}
public class Extend {
public static void main(String[] args)
{
Pupil p = new Pupil(); // 创建子类1对象
p.name = "小红";
p.age = 15;
p.setScore(100);
p.testing();
p.Show();
Gra g = new Gra(); // 创建子类2对象
g.name = "小花";
g.age = 16;
g.setScore(98);
g.testing();
g.Show();
}
}
7. 抽象类
（1）介绍
当父类中的某些方法需要声明，但又不确定该如何实现时，可以将其声明为抽象方法，那么这个类也被称为抽象类。
例：类为Animal，方法为eat，但不确定是什么动物，若是猫则吃鱼，若是狗则吃骨头，无法确定，因此需要声明抽象方法。
（2）实现
一. 初始
public class Abstruct {
public static void main(String[] args)
{
}
}
class Animal
{
private String name;
public Animal(String name)
{
this.name = name;
}
public void eat()
{
System.out.println("这是一个动物，但不知道是什么动物，吃什么?");
}
}二. 改为抽象类
· 去掉方法体，只剩下方法声明，并加上"abstract"改为抽象方法
· 类声明前加上"abstract"改为抽象类
· 一般来说抽象类会有子类来继承，抽象掉的方法，会由子类来实现
· （细节）抽象类不能被实例化，即无法在主方法中new一个抽象类的对象
package chouxiang;
public class Abstract {
public static void main(String[] args)
{
}
}
abstract class Animal
{
private String name;
public Animal(String name)
{
this.name = name;
}
public abstract void eat();
}（3）样例
package chouxiang;
abstract class Animal
{
String name;
public abstract void eat();
}
class Cat extends Animal
{
public void eat() // 重写方法
{
System.out.println(name + "爱吃鱼");
}
}
public class Abstract {
public static void main(String[] args)
{
Cat p = new Cat();
p.name = "小花";
p.eat();
}
}8. 多线程（Thread与Runnable）
（1）方法
通过继承thread类（自带）来实现调用。
（2）实现
一. 继承Thread
public class Thread01 {
public static void main(String[] args) throws InterruptedException
{
Cat p = new Cat();
p.start();
for (int i = 1 ; i <= 10 ; i++)
{
System.out.println(i);
Thread.sleep(1000);
}
}
}
class Cat extends Thread
{
public void run()
{
int i=1;
while (i <= 10)
{
System.out.println("喵喵，我是小猫咪");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
i++;
}
}
}二. Runnable
· 什么时候用Runnable：由于java是单继承，当一个类已经继承了一个父类时，无法再继承Thread，因此只能用接口模式。
public class Thread02 {
public static void main(String[] agrs)
{
Dog p1 = new Dog();
Thread thread = new Thread(p1);
thread.start();
}
}
class Dog implements Runnable
{
public void run()
{
for (int i = 1; i <= 10; i++)
{
System.out.println("第" + i + "小狗汪汪叫");
}
}
}（3）为什么不是直接调用 p.run()
p.start() 是开始p线程，但主线程并不会中断，而是主线程与子线程同时开始。
p.run() 是暂停主线程，调用成员方法，等其结束后再继续主线程。
