本文共 7288 字，大约阅读时间需要 24 分钟。
static：修饰类中的成员变量和普通的方法。不能修饰构造方法。
被static修饰的变量或者方法可以通过类名直接访问，不需要去创建这个类的对象。
被static修饰的变量或者方法在使用的时候，不能直接访问非static修饰的内容。
public class Circle { // 半径 private double radius; /* * 圆周率 : 是所有圆共享的一个常量数据， * 静态之后，变量就会在方法区的静态区中出现， * 而每次创建Circle对象的时候，对象在堆中的内存 * 中就没有pi变量 */ private static double pi = 3.14; public Circle( double radius ) { this.radius = radius; } public double getArea() { return pi * radius * radius; }} public是访问权限修饰，它可以修饰类、方法（普通和构造方法）或变量，被public修饰的类、方法或变量权限最大，在任何程序中都可以被访问。
如果类被public修饰，要求这个类被保存的时候，文件名必须和当前的class的名称保持一致。
当类中的方法需要类意外的程序访问，直接使用public修饰，如果只是在本类中访问，直接使用private修饰。
因为main是被JVM调用，如果权限不是最大的，那么JVM无法调用。
在某些场景下会出现一个类必须要有对象，但是对象的必须是唯一的。这时就称这个类是单例的。
/* * 模拟单例类的书写 */public class SingleClass { // 在这个类中创建本类的对象 private static SingleClass instance = new SingleClass(); // 可以将构造方法私有 private SingleClass() { } // 将这个类的对象对外提供出去 public static SingleClass getInstance() { return instance; } public void print() { System.out.println("Single ........."); }} public class SingleTest { public static void main(String[] args) { // SingleClass 中没有书写构造方法，有个默认的构造方法 // 可以通过空参数的构造方法创建出多个对象 SingleClass sc = SingleClass.getInstance(); SingleClass sc2 = SingleClass.getInstance(); //SingleClass.instance = null; SingleClass sc3 = SingleClass.getInstance(); System.out.println( sc ); System.out.println( sc2 ); System.out.println( sc3 ); sc.print(); sc.print(); sc2.print(); }} 饿汉式
public class Single{ // 创建本类对象 private static Single instance = new Single(); // 私有本类所有构造方法 private Single(){ } // 对外提供获取本类对象的方法 public static Single getInstance(){ return instance; } } 懒汉式
public class Single{ // 只定义本类类型的一个引用变量 private static Single instance = null; // 私有本类所有构造方法 private Single(){ } // 对外提供获取本类对象的方法 public static Single getInstance(){ // 这里需要对多线程访问进行控制（加锁|同步代码块） if( instance == null ){ instance = new Single(); } return instance; } } 开发中一般使用饿汉式，面试问懒汉式（静态、并发问题）。
继承：类是描述某个事物群体的共性特点。生活中事物和事物之间一定存在着某些关系。
例如：
class Dog{ }class Cat{ }class Animal{ }class Pig{ } 用Java中的类描述事物，事物之间有定的关系，说明类与类之间会存在关系。
在Java中类和类之间的关系称为：继承（extends）
Java只支持单继承，不支持多继承，但支持多重继承。
class Fu{ }class Zi extends Fu{ }class Zi2 extends Fu{ } 继承中名词：
子类：Zi属于子类
父类：Fu属于父类
class Person { private String name; private char sex; public String getName() { return name; } public void setName(String name) { this.name = name; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; }}class Student extends Person{ private double score; private String sNo; public void eat() { System.out.println("eat"); } public void study() { System.out.println("study"); }}class Teacher extends Person { private double salary; private String tNo; public void eat() { System.out.println("eat"); } public void work() { System.out.println("work"); }}public class ExtendsDemo { public static void main(String[] args) { Student s = new Student(); s.setName("张三"); }} 子类继承父类，父类中的所有非私有的变量和方法（非构造方法）子类都可以继承到，创建子类对象是可以直接使用的。如果在子类的类中，不用创建对象也能直接访问。
继承可以让子类直接使用父类中的行为等，但是不能因为可以使用父类中的行为而去继承某个类。
Java只支持单继承，不支持多继承，但支持多重继承。
class A{ public void run(){ }}class B{ public void run(){ } }// 多继承，java不支持class C extends A , B{ }class D extends A{ }class E extends A{ }class Test{ public static void main(String[] args){ C c = new C(); // 这里的调用方法出现歧义，导致无法确定到底是用的A父类，还是B父类中的run方法 c.run(); }} /* * 描述手机 */class Phone { private String color; private double price; public void sendMessage() { System.out.println("发短信"); } public void call() { System.out.println("打电话"); }}class HuaWeiP40 extends Phone{ /* * 在子类中出现了和父类功能相同的方法， * 这时子类中可以直接复写（重写、覆盖 override ）父类的这个方法 * 然后在子类中去书写适合子类的方法体 */ public void sendMessage() { System.out.println("发短信同时包含图片"); } public void call2() { System.out.println("视频通话"); }}public class ExtendsDemo2 { public static void main(String[] args) { Phone p = new Phone(); p.sendMessage(); p.call(); HuaWeiP40 hw = new HuaWeiP40(); hw.sendMessage(); }} 方法的重写（ 复写、覆盖 Override ）：
在子父类之间，子类将父类的方法在子类的类体中重写了
方法复写要求：返回值类型、方法名、参数列表完全一致
复写时的方法的修饰符可以不一致，但是子类的方法的修饰符权限必须大于等于父类方法的权限，一般复写的时候，我们就沿用父类的权限即可。
创建子类对象，调用复写的方法，一定执行是子类复写的那个方法，而不会执行父类的方法。
如果子类没有复写父类的方法， 创建子类对象，调用方法的时候一定会执行父类中的方法
class Fu{ int x = 12; public void run() { System.out.println("Fu run ....x = " + x); }}class Zi extends Fu{ int x = 34; public void run() { int x = 56; // 由于方法中x变量，直接输出局部的x变量 System.out.println("Zi run .... x = " + x); // 输出Zi类中的成员变量x System.out.println("Zi run .... x = " + this.x); // 输出Fu类中的成员变量x System.out.println("Zi run .... x = " + super.x); }}public class ExtendsDemo3 { public static void main(String[] args) { //Fu f = new Fu(); //f.run(); Zi z = new Zi(); z.run(); }} super可以在子类中调用父类中方法（ super.父类方法名() ）或者变量( super.变量名 )（不能私有）
在子类的构造方法中调用父类的构造方法，它只能写在子类构造方法中的第一行。super( )；
在任何一个类的构造方法中如果没有手动书写this或者super语句调用构造方法，那么在这个类的构造方法的第一行中有个隐式的super( ) 语句在调用父类空参数的构造方法。
// 员工类class Employee{ private String name; private int age; private double salary; public Employee(String name, int age, double salary) { this.name = name; this.age = age; this.salary = salary; } }// 程序员class Coder extends Employee{ public Coder(String name, int age, double salary) { super( name , age , salary ); }}// 项目经理class CoderManager extends Employee{ public CoderManager(String name, int age, double salary) { super(name, age, salary); } }public class ExtendsDemo4 { public static void main(String[] args) { Coder c = new Coder("张三" , 23 , 8000 ); }} 如果父类中没有空参数的构造方法，子类的构造方法中一定要手动添加super语句，显示指定调用父类有参数的构造方法。
在Java中任何一个类如果没有直接书写它的父类，这时这个类一定会有一个超级父类Object。
Object类中定义的方法是所有类最共性的方法，任何子类都可以直接使用。
一般在项目中我们都需要去复写Object类中的equals、hashCode、toString三个方法。
final它也是一个修饰符，它可以修饰类、方法（非构造方法）、变量（成员变量或局部变量）
当我们在程序中定义一个类的时候，如果这个类不能被的别类继承，需要使用final修饰。
final修饰的类：最终类，不能再有子类。
final class Demo{ }// 程序编译会出错class Demo2 extends Demo{ } 一个类可以有子类（这个类能够被继承），类中有部分的方法是不允许子类复写的，这时可以使用final修饰这些不能被复写（重写、覆盖）的方法。
class Demo{ public void run(){ } // 它是一个最终方法 public final void method(){ }}class Demo2 extends Demo{ // 编译报错，因为method无法被子类复写 public void method(){ }} fianl修饰的变量，为常量，变量空间的数据永远无法改变。
class Demo{ // 这个x是一个最终的变量 private final int x = 12; public void setX( int x){ this.x = x; } public void func(){ // y也是一个最终的变量，无法改变y空间的值 final int y = 23; }} 转载地址：http://yqtgn.baihongyu.com/