目录
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 blocke.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() 是暂停主线程，调用成员方法，等其结束后再继续主线程。
